0001: # Egress (QWP/WebSocket reader) Cython glue.

 0002: #

 0003: # `QueryResult` exposes the Arrow PyCapsule Interface

 0004: # (`__arrow_c_stream__`) directly off the Rust cursor, so polars /

 0005: # duckdb / pandas 3.0 / any Arrow-native consumer can read query

 0006: # results without pyarrow. `to_pandas` / `iter_pandas` default to a

 0007: # pyarrow-free native numpy path; `to_arrow` / `iter_arrow` /

 0008: # `to_polars` / `iter_polars` lazy-import pyarrow.

 0009: 

 0010: cimport numpy as cnp

 0011: 

 0012: 

+0013: cdef inline object _reader_err_code_to_py(questdb_error_code code):

static CYTHON_INLINE PyObject *__pyx_f_7questdb_7_client__reader_err_code_to_py(questdb_error_code __pyx_v_code) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("questdb._client._reader_err_code_to_py", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0014:     # The error model is unified: `questdb_error_code` is an alias of

 0015:     # `line_sender_error_code`, so reader errors decode through the single

 0016:     # shared map. Every reader category now has its own `QuestDBErrorCode`

 0017:     # member (handshake, protocol, invalid bind, schema drift, the

 0018:     # server-side errors, ...) instead of the former `ServerFlushError`

 0019:     # bucket.

+0020:     return c_err_code_to_py(code)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_7questdb_7_client_c_err_code_to_py(__pyx_v_code); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 20, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0021: 

 0022: 

+0023: cdef inline object _reader_err_to_py(questdb_error* err):

static CYTHON_INLINE PyObject *__pyx_f_7questdb_7_client__reader_err_to_py(questdb_error *__pyx_v_err) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("questdb._client._reader_err_to_py", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0024:     """Construct a ``QuestDBError`` from a ``questdb_error*`` and free it."""

+0025:     return c_err_to_py(err)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_7questdb_7_client_c_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0026: 

 0027: 

+0028: cdef class _ReaderHandle:

struct __pyx_obj_7questdb_7_client__ReaderHandle {
  PyObject_HEAD
  struct __pyx_vtabstruct_7questdb_7_client__ReaderHandle *__pyx_vtab;
  struct qwp_reader *_reader;
  int _must_close;
};
/* … */
struct __pyx_vtabstruct_7questdb_7_client__ReaderHandle {
  PyObject *(*_attach)(struct __pyx_obj_7questdb_7_client__ReaderHandle *, struct qwp_reader *);
  void (*_close)(struct __pyx_obj_7questdb_7_client__ReaderHandle *);
};
static struct __pyx_vtabstruct_7questdb_7_client__ReaderHandle *__pyx_vtabptr_7questdb_7_client__ReaderHandle;

 0029:     """Owns a ``qwp_reader*``.

 0030: 

 0031:     ``_close()`` runs eagerly when the owning ``_CursorHandle`` is

 0032:     freed (clean drain, ``QueryResult.close()``, or consumer

 0033:     teardown); ``__dealloc__`` is the idempotent backstop. On close

 0034:     the reader either returns to its pool or is dropped,

 0035:     depending on the ``reader``'s own ownership tag (set when it

 0036:     was constructed — see ``ReaderOwnership`` in the Rust FFI):

 0037: 

 0038:     - Pool-borrowed readers go back to the pool unless

 0039:       ``_must_close`` was set, in which case the pool drops them.

 0040:     - Standalone readers (from ``reader_from_conf``) are always

 0041:       dropped.

 0042: 

 0043:     The Python side carries only one extra bit of state —

 0044:     ``_must_close`` — which it forwards to the FFI via

 0045:     ``qwp_reader_drop_on_return`` before calling close. We never

 0046:     hold a raw ``questdb_db*`` pointer here: the reader struct

 0047:     holds an ``Arc<DbInner>`` internally, so the pool stays alive

 0048:     even if the user's ``QuestDB.close()`` ran after ``query()``

 0049:     returned but before the reader closed.

 0050: 

 0051:     ``_must_close`` defaults to ``True``: only the generator's

 0052:     clean-drain path (or code that explicitly knows the cursor

 0053:     reached terminal) clears it. Any error path or abandon-without-

 0054:     consume path forces the reader to drop, since the Rust

 0055:     Cursor::Drop closes the transport whenever ``cursor_active`` is

 0056:     still set at drop time — recycling such a reader would hand the

 0057:     next borrower a broken pipe.

 0058:     """

 0059:     cdef qwp_reader* _reader

 0060:     cdef bint _must_close

 0061: 

+0062:     def __cinit__(self):

/* Python wrapper */
static int __pyx_pw_7questdb_7_client_13_ReaderHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_7questdb_7_client_13_ReaderHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return -1;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__cinit__", __pyx_kwds); return -1;}
  __pyx_r = __pyx_pf_7questdb_7_client_13_ReaderHandle___cinit__(((struct __pyx_obj_7questdb_7_client__ReaderHandle *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_7questdb_7_client_13_ReaderHandle___cinit__(struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_self) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  return __pyx_r;
}

+0063:         self._reader = NULL

  __pyx_v_self->_reader = NULL;

+0064:         self._must_close = True

  __pyx_v_self->_must_close = 1;

 0065: 

+0066:     cdef _attach(self, qwp_reader* reader):

static PyObject *__pyx_f_7questdb_7_client_13_ReaderHandle__attach(struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_self, struct qwp_reader *__pyx_v_reader) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0067:         self._reader = reader

  __pyx_v_self->_reader = __pyx_v_reader;

 0068: 

+0069:     cdef void _close(self) noexcept:

static void __pyx_f_7questdb_7_client_13_ReaderHandle__close(struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_self) {
  PyThreadState *__pyx_v_gs;
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("questdb._client._ReaderHandle._close", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
}

+0070:         cdef PyThreadState* gs = NULL

  __pyx_v_gs = NULL;

+0071:         if self._reader == NULL:

  __pyx_t_1 = (__pyx_v_self->_reader == NULL);
  if (__pyx_t_1) {
/* … */
  }

+0072:             return

    goto __pyx_L0;

+0073:         if self._must_close:

  if (__pyx_v_self->_must_close) {
/* … */
  }

+0074:             qwp_reader_drop_on_return(self._reader)

    qwp_reader_drop_on_return(__pyx_v_self->_reader);

+0075:         _ensure_doesnt_have_gil(&gs)

  __pyx_t_1 = __pyx_f_7questdb_7_client__ensure_doesnt_have_gil((&__pyx_v_gs)); if (unlikely(__pyx_t_1 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 75, __pyx_L1_error)

+0076:         qwp_reader_close(self._reader)

  qwp_reader_close(__pyx_v_self->_reader);

+0077:         _ensure_has_gil(&gs)

  __pyx_f_7questdb_7_client__ensure_has_gil((&__pyx_v_gs)); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 77, __pyx_L1_error)

+0078:         self._reader = NULL

  __pyx_v_self->_reader = NULL;

 0079: 

+0080:     def __dealloc__(self):

/* Python wrapper */
static void __pyx_pw_7questdb_7_client_13_ReaderHandle_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_7questdb_7_client_13_ReaderHandle_3__dealloc__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_pf_7questdb_7_client_13_ReaderHandle_2__dealloc__(((struct __pyx_obj_7questdb_7_client__ReaderHandle *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_7questdb_7_client_13_ReaderHandle_2__dealloc__(struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_self) {
/* … */
  /* function exit code */
}

+0081:         self._close()

  ((struct __pyx_vtabstruct_7questdb_7_client__ReaderHandle *)__pyx_v_self->__pyx_vtab)->_close(__pyx_v_self);

 0082: 

 0083: 

+0084: @cython.no_gc_clear

struct __pyx_obj_7questdb_7_client__CursorHandle {
  PyObject_HEAD
  struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *__pyx_vtab;
  struct qwp_reader_cursor *_cursor;
  struct __pyx_obj_7questdb_7_client__ReaderHandle *_reader_ref;
  int _owns_reader;
  PyObject *_lock;
  int _reset_seq;
};
/* … */
struct __pyx_vtabstruct_7questdb_7_client__CursorHandle {
  PyObject *(*_attach)(struct __pyx_obj_7questdb_7_client__CursorHandle *, struct qwp_reader_cursor *, struct __pyx_obj_7questdb_7_client__ReaderHandle *);
  void (*_free)(struct __pyx_obj_7questdb_7_client__CursorHandle *);
};
static struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *__pyx_vtabptr_7questdb_7_client__CursorHandle;

 0085: cdef class _CursorHandle:

 0086:     """Owns a ``qwp_reader_cursor*`` + back-ref to its reader.

 0087: 

 0088:     ``_free()`` releases both: the cursor is freed and the reader

 0089:     closed (returned to its pool or dropped) in the same locked

 0090:     section. The drain / close / consumer-teardown paths call it

 0091:     eagerly; ``__dealloc__`` is the backstop.

 0092: 

 0093:     ``_owns_reader`` selects who releases the reader. The one-shot

 0094:     ``QuestDB.query(sql)`` path leaves it ``True``: the cursor is the

 0095:     reader's sole owner, so ``_free()`` closes the reader eagerly. A

 0096:     ``PooledReader`` lease sets it ``False``: the lease keeps its

 0097:     reader across queries, so ``_free()`` releases only the cursor and

 0098:     drops the back-reference. The clean-drain paths clear

 0099:     ``_reader_ref._must_close`` *before* calling ``_free()``, so the

 0100:     lease still observes whether the stream reached its terminal.

 0101: 

 0102:     ``_reset_seq`` counts mid-query failover resets. The

 0103:     ``_failover_reset_trampoline`` installed on the materialise-whole

 0104:     query path bumps it (a plain C-field write, no GIL, no FFI, no

 0105:     exception — honouring the reader's reentrancy contract) when the

 0106:     cursor re-executes the query on a new endpoint. The accumulating

 0107:     reader (``_numpy_frame_from_cursor`` etc.) compares it against the

 0108:     sequence it observed at start-of-stream and, when it advanced,

 0109:     discards every batch buffered so far so the replay-from-batch-0

 0110:     yields a correct whole result.

 0111:     """

 0112:     cdef qwp_reader_cursor* _cursor

 0113:     cdef _ReaderHandle _reader_ref

 0114:     cdef bint _owns_reader

 0115:     cdef object _lock

 0116:     cdef int _reset_seq

 0117: 

+0118:     def __cinit__(self):

/* Python wrapper */
static int __pyx_pw_7questdb_7_client_13_CursorHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_7questdb_7_client_13_CursorHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return -1;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__cinit__", __pyx_kwds); return -1;}
  __pyx_r = __pyx_pf_7questdb_7_client_13_CursorHandle___cinit__(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_7questdb_7_client_13_CursorHandle___cinit__(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_self) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("questdb._client._CursorHandle.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0119:         self._cursor = NULL

  __pyx_v_self->_cursor = NULL;

+0120:         self._reader_ref = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_reader_ref);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_reader_ref);
  __pyx_v_self->_reader_ref = ((struct __pyx_obj_7questdb_7_client__ReaderHandle *)Py_None);

+0121:         self._owns_reader = True

  __pyx_v_self->_owns_reader = 1;

+0122:         self._lock = threading.Lock()

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Lock); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_5 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->_lock);
  __Pyx_DECREF(__pyx_v_self->_lock);
  __pyx_v_self->_lock = __pyx_t_1;
  __pyx_t_1 = 0;

+0123:         self._reset_seq = 0

  __pyx_v_self->_reset_seq = 0;

 0124: 

+0125:     cdef _attach(self, qwp_reader_cursor* cursor, _ReaderHandle reader_ref):

static PyObject *__pyx_f_7questdb_7_client_13_CursorHandle__attach(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_self, struct qwp_reader_cursor *__pyx_v_cursor, struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_reader_ref) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0126:         self._cursor = cursor

  __pyx_v_self->_cursor = __pyx_v_cursor;

+0127:         self._reader_ref = reader_ref

  __Pyx_INCREF((PyObject *)__pyx_v_reader_ref);
  __Pyx_GIVEREF((PyObject *)__pyx_v_reader_ref);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->_reader_ref);
  __Pyx_DECREF((PyObject *)__pyx_v_self->_reader_ref);
  __pyx_v_self->_reader_ref = __pyx_v_reader_ref;

 0128: 

+0129:     cdef void _free(self) noexcept:

static void __pyx_f_7questdb_7_client_13_CursorHandle__free(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_self) {
  PyThreadState *__pyx_v_gs;
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_WriteUnraisable("questdb._client._CursorHandle._free", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
}

+0130:         cdef PyThreadState* gs = NULL

  __pyx_v_gs = NULL;

+0131:         with self._lock:

  /*with:*/ {
    __pyx_t_1 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 131, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = NULL;
    __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 131, __pyx_L3_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 131, __pyx_L3_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    /*try:*/ {
      {
        /*try:*/ {
/* … */
        }
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        goto __pyx_L12_try_end;
        __pyx_L7_error:;
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        /*except:*/ {
          __Pyx_AddTraceback("questdb._client._CursorHandle._free", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_3) < 0) __PYX_ERR(2, 131, __pyx_L9_except_error)
          __Pyx_XGOTREF(__pyx_t_2);
          __Pyx_XGOTREF(__pyx_t_4);
          __Pyx_XGOTREF(__pyx_t_3);
          __pyx_t_10 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 131, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_10);
          __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 131, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_11);
          __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_11);
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          if (__pyx_t_9 < (0)) __PYX_ERR(2, 131, __pyx_L9_except_error)
          __pyx_t_12 = (!__pyx_t_9);
          if (unlikely(__pyx_t_12)) {
            __Pyx_GIVEREF(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_4);
            __Pyx_XGIVEREF(__pyx_t_3);
            __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_4, __pyx_t_3);
            __pyx_t_2 = 0;  __pyx_t_4 = 0;  __pyx_t_3 = 0; 
            __PYX_ERR(2, 131, __pyx_L9_except_error)
          }
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          goto __pyx_L8_exception_handled;
        }
        __pyx_L9_except_error:;
        __Pyx_XGIVEREF(__pyx_t_6);
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
        goto __pyx_L1_error;
        __pyx_L8_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_6);
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
        __pyx_L12_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_1) {
          __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[2], NULL);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 131, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        }
        goto __pyx_L6;
      }
      __pyx_L6:;
    }
    goto __pyx_L19;
    __pyx_L3_error:;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    goto __pyx_L1_error;
    __pyx_L19:;
  }
/* … */
  __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(2, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]);

+0132:             if self._cursor != NULL:

          __pyx_t_9 = (__pyx_v_self->_cursor != NULL);
          if (__pyx_t_9) {
/* … */
          }

+0133:                 _ensure_doesnt_have_gil(&gs)

            __pyx_t_9 = __pyx_f_7questdb_7_client__ensure_doesnt_have_gil((&__pyx_v_gs)); if (unlikely(__pyx_t_9 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 133, __pyx_L7_error)

+0134:                 qwp_reader_cursor_free(self._cursor)

            qwp_reader_cursor_free(__pyx_v_self->_cursor);

+0135:                 _ensure_has_gil(&gs)

            __pyx_f_7questdb_7_client__ensure_has_gil((&__pyx_v_gs)); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 135, __pyx_L7_error)

+0136:                 self._cursor = NULL

            __pyx_v_self->_cursor = NULL;

+0137:             if self._reader_ref is not None:

          __pyx_t_9 = (((PyObject *)__pyx_v_self->_reader_ref) != Py_None);
          if (__pyx_t_9) {
/* … */
          }

+0138:                 if self._owns_reader:

            if (__pyx_v_self->_owns_reader) {
/* … */
            }

+0139:                     self._reader_ref._close()

              ((struct __pyx_vtabstruct_7questdb_7_client__ReaderHandle *)__pyx_v_self->_reader_ref->__pyx_vtab)->_close(__pyx_v_self->_reader_ref);

+0140:                 self._reader_ref = None

            __Pyx_INCREF(Py_None);
            __Pyx_GIVEREF(Py_None);
            __Pyx_GOTREF((PyObject *)__pyx_v_self->_reader_ref);
            __Pyx_DECREF((PyObject *)__pyx_v_self->_reader_ref);
            __pyx_v_self->_reader_ref = ((struct __pyx_obj_7questdb_7_client__ReaderHandle *)Py_None);

 0141: 

+0142:     def __dealloc__(self):

/* Python wrapper */
static void __pyx_pw_7questdb_7_client_13_CursorHandle_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_7questdb_7_client_13_CursorHandle_3__dealloc__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_pf_7questdb_7_client_13_CursorHandle_2__dealloc__(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_7questdb_7_client_13_CursorHandle_2__dealloc__(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_self) {
/* … */
  /* function exit code */
}

+0143:         self._free()

  ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_self->__pyx_vtab)->_free(__pyx_v_self);

 0144: 

 0145: 

+0146: cdef object _fetch_one_batch(

static PyObject *__pyx_f_7questdb_7_client__fetch_one_batch(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle, PyObject *__pyx_v_pa_module, struct __pyx_opt_args_7questdb_7_client__fetch_one_batch *__pyx_optional_args) {
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("questdb._client._fetch_one_batch", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_opt_args_7questdb_7_client__fetch_one_batch {
  int __pyx_n;
  int compact;
};

+0147:         _CursorHandle handle, object pa_module, bint compact=False):

  int __pyx_v_compact = ((int)0);
  struct ArrowArray __pyx_v_array;
  struct ArrowSchema __pyx_v_schema;
  questdb_error *__pyx_v_err;
  enum qwp_reader_arrow_batch_result __pyx_v_result;
  struct qwp_reader_cursor *__pyx_v_cursor;
  PyObject *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_compact = __pyx_optional_args->compact;
    }
  }

 0148:     """Pull one batch via qwp_reader_cursor_next_arrow_batch.

 0149: 

 0150:     Returns:

 0151:       - None on clean end-of-stream.

 0152:       - A pyarrow.RecordBatch on success.

 0153:     Raises QuestDBError on FFI error.

 0154:     """

 0155:     cdef ArrowArray array

 0156:     cdef ArrowSchema schema

+0157:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 0158:     cdef qwp_reader_arrow_batch_result result

 0159:     cdef qwp_reader_cursor* cursor

 0160: 

+0161:     with handle._lock:

  /*with:*/ {
    __pyx_t_1 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 161, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = NULL;
    __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 161, __pyx_L3_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 161, __pyx_L3_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    /*try:*/ {
      {
        /*try:*/ {
/* … */
        }
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        goto __pyx_L12_try_end;
        __pyx_L7_error:;
        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        /*except:*/ {
          __Pyx_AddTraceback("questdb._client._fetch_one_batch", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_12) < 0) __PYX_ERR(2, 161, __pyx_L9_except_error)
          __Pyx_XGOTREF(__pyx_t_2);
          __Pyx_XGOTREF(__pyx_t_3);
          __Pyx_XGOTREF(__pyx_t_12);
          __pyx_t_4 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_3, __pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 161, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 161, __pyx_L9_except_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          if (__pyx_t_10 < (0)) __PYX_ERR(2, 161, __pyx_L9_except_error)
          __pyx_t_14 = (!__pyx_t_10);
          if (unlikely(__pyx_t_14)) {
            __Pyx_GIVEREF(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_3);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_3, __pyx_t_12);
            __pyx_t_2 = 0;  __pyx_t_3 = 0;  __pyx_t_12 = 0; 
            __PYX_ERR(2, 161, __pyx_L9_except_error)
          }
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          goto __pyx_L8_exception_handled;
        }
        __pyx_L9_except_error:;
        __Pyx_XGIVEREF(__pyx_t_6);
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
        goto __pyx_L1_error;
        __pyx_L8_exception_handled:;
        __Pyx_XGIVEREF(__pyx_t_6);
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
        __pyx_L12_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_1) {
          __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[2], NULL);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 161, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        }
        goto __pyx_L6;
      }
      __pyx_L6:;
    }
    goto __pyx_L21;
    __pyx_L3_error:;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    goto __pyx_L1_error;
    __pyx_L21:;
  }

+0162:         cursor = handle._cursor

          __pyx_t_9 = __pyx_v_handle->_cursor;
          __pyx_v_cursor = __pyx_t_9;

+0163:         if cursor == NULL:

          __pyx_t_10 = (__pyx_v_cursor == NULL);
          if (unlikely(__pyx_t_10)) {
/* … */
          }

+0164:             raise QuestDBError(

            __pyx_t_4 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 164, __pyx_L7_error)
            __Pyx_GOTREF(__pyx_t_3);

+0165:                 QuestDBErrorCode.InvalidApiCall,

            __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 165, __pyx_L7_error)
            __Pyx_GOTREF(__pyx_t_11);
            __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 165, __pyx_L7_error)
            __Pyx_GOTREF(__pyx_t_12);
            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
            __pyx_t_5 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_3))) {
              __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
              assert(__pyx_t_4);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
              __Pyx_INCREF(__pyx_t_4);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
              __pyx_t_5 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_12, __pyx_mstate_global->__pyx_kp_u_cursor_is_closed};
              __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
              __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 164, __pyx_L7_error)
              __Pyx_GOTREF(__pyx_t_2);
            }
            __Pyx_Raise(__pyx_t_2, 0, 0, 0);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __PYX_ERR(2, 164, __pyx_L7_error)

 0166:                 'cursor is closed')

+0167:         with nogil:

          {
              PyThreadState * _save;
              _save = PyEval_SaveThread();
              __Pyx_FastGIL_Remember();
              /*try:*/ {
/* … */
              /*finally:*/ {
                /*normal exit:*/{
                  __Pyx_FastGIL_Forget();
                  PyEval_RestoreThread(_save);
                  goto __pyx_L16;
                }
                __pyx_L16:;
              }
          }

+0168:             if compact:

                if (__pyx_v_compact) {
/* … */
                  goto __pyx_L17;
                }

+0169:                 result = qwp_reader_cursor_next_arrow_batch_compact(

                  __pyx_v_result = qwp_reader_cursor_next_arrow_batch_compact(__pyx_v_cursor, (&__pyx_v_array), (&__pyx_v_schema), (&__pyx_v_err));

 0170:                     cursor, &array, &schema, &err)

 0171:             else:

+0172:                 result = qwp_reader_cursor_next_arrow_batch(

                /*else*/ {
/* … */
                  __pyx_v_result = qwp_reader_cursor_next_arrow_batch(__pyx_v_cursor, (&__pyx_v_array), (&__pyx_v_schema), (&__pyx_v_err));
                }
                __pyx_L17:;
              }

 0173:                     cursor, &array, &schema, &err)

 0174: 

+0175:     if result == qwp_reader_arrow_batch_ok:

  __pyx_t_14 = (__pyx_v_result == qwp_reader_arrow_batch_ok);
  if (__pyx_t_14) {
/* … */
  }

 0176:         # Hand ownership of the array + schema buffers to pyarrow.

 0177:         # _import_from_c moves the structs and nulls their release

 0178:         # callbacks; pyarrow's RecordBatch owns the buffers from here.

+0179:         try:

    {
      /*try:*/ {
/* … */
      }
      __pyx_L23_error:;
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
      __pyx_L25_except_error:;
      __Pyx_XGIVEREF(__pyx_t_1);
      __Pyx_XGIVEREF(__pyx_t_8);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_8, __pyx_t_7);
      goto __pyx_L1_error;
      __pyx_L27_try_return:;
      __Pyx_XGIVEREF(__pyx_t_1);
      __Pyx_XGIVEREF(__pyx_t_8);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_8, __pyx_t_7);
      goto __pyx_L0;
    }

+0180:             return pa_module.RecordBatch._import_from_c(

        __Pyx_XDECREF(__pyx_r);
        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa_module, __pyx_mstate_global->__pyx_n_u_RecordBatch); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 180, __pyx_L23_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_3 = __pyx_t_2;
        __Pyx_INCREF(__pyx_t_3);

+0181:                 <uintptr_t>&array, <uintptr_t>&schema)

        __pyx_t_4 = __Pyx_PyLong_FromSize_t(((uintptr_t)(&__pyx_v_array))); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 181, __pyx_L23_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_11 = __Pyx_PyLong_FromSize_t(((uintptr_t)(&__pyx_v_schema))); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 181, __pyx_L23_error)
        __Pyx_GOTREF(__pyx_t_11);
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_4, __pyx_t_11};
          __pyx_t_12 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_import_from_c, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 180, __pyx_L23_error)
          __Pyx_GOTREF(__pyx_t_12);
        }
        __pyx_r = __pyx_t_12;
        __pyx_t_12 = 0;
        goto __pyx_L27_try_return;

+0182:         except:

      /*except:*/ {
        __Pyx_AddTraceback("questdb._client._fetch_one_batch", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_2, &__pyx_t_11) < 0) __PYX_ERR(2, 182, __pyx_L25_except_error)
        __Pyx_XGOTREF(__pyx_t_12);
        __Pyx_XGOTREF(__pyx_t_2);
        __Pyx_XGOTREF(__pyx_t_11);

+0183:             if array.release != NULL:

        __pyx_t_14 = (__pyx_v_array.release != NULL);
        if (__pyx_t_14) {
/* … */
        }

+0184:                 array.release(&array)

          __pyx_v_array.release((&__pyx_v_array));

+0185:             if schema.release != NULL:

        __pyx_t_14 = (__pyx_v_schema.release != NULL);
        if (__pyx_t_14) {
/* … */
        }

+0186:                 schema.release(&schema)

          __pyx_v_schema.release((&__pyx_v_schema));

+0187:             raise

        __Pyx_GIVEREF(__pyx_t_12);
        __Pyx_GIVEREF(__pyx_t_2);
        __Pyx_XGIVEREF(__pyx_t_11);
        __Pyx_ErrRestoreWithState(__pyx_t_12, __pyx_t_2, __pyx_t_11);
        __pyx_t_12 = 0;  __pyx_t_2 = 0;  __pyx_t_11 = 0; 
        __PYX_ERR(2, 187, __pyx_L25_except_error)
      }

 0188: 

+0189:     if result == qwp_reader_arrow_batch_end:

  __pyx_t_14 = (__pyx_v_result == qwp_reader_arrow_batch_end);
  if (__pyx_t_14) {
/* … */
  }

+0190:         return None

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

 0191: 

 0192:     # Error path.

+0193:     if err == NULL:

  __pyx_t_14 = (__pyx_v_err == NULL);
  if (unlikely(__pyx_t_14)) {
/* … */
  }

+0194:         raise QuestDBError(

    __pyx_t_2 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 194, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);

+0195:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 195, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 195, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_12))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_12);
      assert(__pyx_t_2);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_12, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_qwp_reader_cursor_next_arrow_bat};
      __pyx_t_11 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 194, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
    }
    __Pyx_Raise(__pyx_t_11, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __PYX_ERR(2, 194, __pyx_L1_error)

 0196:             'qwp_reader_cursor_next_arrow_batch returned error '

 0197:             'without setting err_out')

+0198:     raise _reader_err_to_py(err)

  __pyx_t_11 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 198, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __Pyx_Raise(__pyx_t_11, 0, 0, 0);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __PYX_ERR(2, 198, __pyx_L1_error)

 0199: 

 0200: 

+0201: cdef tuple _fetch_all_record_batches(

static PyObject *__pyx_f_7questdb_7_client__fetch_all_record_batches(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle, PyObject *__pyx_v_pa_module, struct __pyx_opt_args_7questdb_7_client__fetch_all_record_batches *__pyx_optional_args) {
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client._fetch_all_record_batches", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_schema);
  __Pyx_XDECREF(__pyx_v_batches);
  __Pyx_XDECREF(__pyx_v_batch);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_7questdb_7_client_26_build_record_batch_reader_2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
struct __pyx_opt_args_7questdb_7_client__fetch_all_record_batches {
  int __pyx_n;
  int compact;
};

+0202:         _CursorHandle handle, object pa_module, bint compact=False):

  int __pyx_v_compact = ((int)0);
  int __pyx_v_seen_seq;
  PyObject *__pyx_v_schema = 0;
  PyObject *__pyx_v_batches = 0;
  PyObject *__pyx_v_batch = 0;
  PyObject *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_compact = __pyx_optional_args->compact;
    }
  }

 0203:     """Drain the cursor into a list of ``pyarrow.RecordBatch`` we own.

 0204: 

 0205:     The materialise-whole entry points install the failover-reset

 0206:     trampoline, which bumps ``handle._reset_seq`` when a mid-query

 0207:     failover re-executes the query on a new endpoint. Because we own the

 0208:     accumulator here, on a reset we discard every batch buffered so far

 0209:     and restart from the replayed batch-0 — yielding a correct,

 0210:     duplicate-free whole result. Returns ``(schema_or_None, batches)``;

 0211:     the cursor is freed and the reader marked drained on clean

 0212:     end-of-stream.

 0213:     """

+0214:     cdef int seen_seq = handle._reset_seq

  __pyx_t_1 = __pyx_v_handle->_reset_seq;
  __pyx_v_seen_seq = __pyx_t_1;

+0215:     cdef object schema = None

  __Pyx_INCREF(Py_None);
  __pyx_v_schema = Py_None;

+0216:     cdef list batches = []

  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_batches = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 0217:     cdef object batch

+0218:     try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_XGIVEREF(__pyx_t_4);
    __Pyx_XGIVEREF(__pyx_t_5);
    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
    goto __pyx_L1_error;
    __pyx_L8_try_end:;
  }

+0219:         while True:

      while (1) {

+0220:             batch = _fetch_one_batch(handle, pa_module, compact)

        __pyx_t_6.__pyx_n = 1;
        __pyx_t_6.compact = __pyx_v_compact;
        __pyx_t_2 = __pyx_f_7questdb_7_client__fetch_one_batch(__pyx_v_handle, __pyx_v_pa_module, &__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 220, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_XDECREF_SET(__pyx_v_batch, __pyx_t_2);
        __pyx_t_2 = 0;

+0221:             if handle._reset_seq != seen_seq:

        __pyx_t_7 = (__pyx_v_handle->_reset_seq != __pyx_v_seen_seq);
        if (__pyx_t_7) {
/* … */
        }

 0222:                 # Mid-query failover replayed from batch-0: drop the

 0223:                 # pre-failover accumulation and re-pin the schema.

+0224:                 seen_seq = handle._reset_seq

          __pyx_t_1 = __pyx_v_handle->_reset_seq;
          __pyx_v_seen_seq = __pyx_t_1;

+0225:                 batches = []

          __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 225, __pyx_L3_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_DECREF_SET(__pyx_v_batches, ((PyObject*)__pyx_t_2));
          __pyx_t_2 = 0;

+0226:                 schema = None

          __Pyx_INCREF(Py_None);
          __Pyx_DECREF_SET(__pyx_v_schema, Py_None);

+0227:             if batch is None:

        __pyx_t_7 = (__pyx_v_batch == Py_None);
        if (__pyx_t_7) {
/* … */
        }

+0228:                 break

          goto __pyx_L10_break;

+0229:             if schema is None:

        __pyx_t_7 = (__pyx_v_schema == Py_None);
        if (__pyx_t_7) {
/* … */
        }

+0230:                 schema = batch.schema

          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_batch, __pyx_mstate_global->__pyx_n_u_schema); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 230, __pyx_L3_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_DECREF_SET(__pyx_v_schema, __pyx_t_2);
          __pyx_t_2 = 0;

+0231:             batches.append(batch)

        __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_batches, __pyx_v_batch); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 231, __pyx_L3_error)
      }
      __pyx_L10_break:;

+0232:     except:

    /*except:*/ {
      __Pyx_AddTraceback("questdb._client._fetch_all_record_batches", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(2, 232, __pyx_L5_except_error)
      __Pyx_XGOTREF(__pyx_t_2);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);

+0233:         handle._free()

      ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_handle->__pyx_vtab)->_free(__pyx_v_handle);

+0234:         raise

      __Pyx_GIVEREF(__pyx_t_2);
      __Pyx_GIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_9, __pyx_t_10);
      __pyx_t_2 = 0;  __pyx_t_9 = 0;  __pyx_t_10 = 0; 
      __PYX_ERR(2, 234, __pyx_L5_except_error)
    }

+0235:     _mark_reader_drained(handle)

  __pyx_f_7questdb_7_client__mark_reader_drained(__pyx_v_handle);

+0236:     handle._free()

  ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_handle->__pyx_vtab)->_free(__pyx_v_handle);

+0237:     return (schema, batches)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 237, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_INCREF(__pyx_v_schema);
  __Pyx_GIVEREF(__pyx_v_schema);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_schema) != (0)) __PYX_ERR(2, 237, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_batches);
  __Pyx_GIVEREF(__pyx_v_batches);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_batches) != (0)) __PYX_ERR(2, 237, __pyx_L1_error);
  __pyx_r = ((PyObject*)__pyx_t_10);
  __pyx_t_10 = 0;
  goto __pyx_L0;

 0238: 

 0239: 

+0240: cdef object _build_record_batch_reader(

static PyObject *__pyx_f_7questdb_7_client__build_record_batch_reader(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_cursor_handle, struct __pyx_opt_args_7questdb_7_client__build_record_batch_reader *__pyx_optional_args) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader *__pyx_cur_scope;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client._build_record_batch_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_empty);
  __Pyx_XDECREF(__pyx_v_schema);
  __Pyx_XDECREF(__pyx_v__gen);
  __Pyx_XDECREF(__pyx_gb_7questdb_7_client_26_build_record_batch_reader_2generator2);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_opt_args_7questdb_7_client__build_record_batch_reader {
  int __pyx_n;
  int compact;
};
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader {
  PyObject_HEAD
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_cursor_handle;
  PyObject *__pyx_v_first;
  PyObject *__pyx_v_pa;
  int __pyx_v_seen_seq;
};

+0241:         _CursorHandle cursor_handle, bint compact=False):

  int __pyx_v_compact = ((int)0);
  PyObject *__pyx_v_empty = NULL;
  PyObject *__pyx_v_schema = NULL;
  PyObject *__pyx_v__gen = 0;
  PyObject *__pyx_gb_7questdb_7_client_26_build_record_batch_reader_2generator2 = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 240, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_compact = __pyx_optional_args->compact;
    }
  }
  __pyx_cur_scope->__pyx_v_cursor_handle = __pyx_v_cursor_handle;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_cursor_handle);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_cursor_handle);

 0242:     """Construct a pyarrow.RecordBatchReader over the cursor.

 0243: 

 0244:     Peeks the first batch to capture the stream schema, then yields

 0245:     the remaining batches lazily. The cursor is explicitly freed when

 0246:     the underlying generator completes (exhaustion, exception, or

 0247:     close), so the owning reader can be closed without leaking a live

 0248:     cursor.

 0249:     """

+0250:     import pyarrow as pa

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 250, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_pa = __pyx_t_1;
  __pyx_t_1 = 0;

 0251: 

+0252:     first = _fetch_one_batch(cursor_handle, pa, compact)

  __pyx_t_1 = ((PyObject *)__pyx_cur_scope->__pyx_v_cursor_handle);
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_3 = __pyx_cur_scope->__pyx_v_pa;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_5.__pyx_n = 1;
  __pyx_t_5.compact = __pyx_v_compact;
  __pyx_t_4 = __pyx_f_7questdb_7_client__fetch_one_batch(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1), __pyx_t_3, &__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_cur_scope->__pyx_v_first = __pyx_t_4;
  __pyx_t_4 = 0;

+0253:     if first is None:

  __pyx_t_6 = (__pyx_cur_scope->__pyx_v_first == Py_None);
  if (__pyx_t_6) {
/* … */
  }

 0254:         # No result set (a non-SELECT statement ends with EXEC_DONE and

 0255:         # ships no RESULT_BATCH), so there is no schema to surface; an

 0256:         # empty SELECT still ships a zero-row batch carrying the schema.

+0257:         _mark_reader_drained(cursor_handle)

    __pyx_t_4 = ((PyObject *)__pyx_cur_scope->__pyx_v_cursor_handle);
    __Pyx_INCREF(__pyx_t_4);
    __pyx_f_7questdb_7_client__mark_reader_drained(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_4));
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0258:         cursor_handle._free()

    ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_cur_scope->__pyx_v_cursor_handle->__pyx_vtab)->_free(__pyx_cur_scope->__pyx_v_cursor_handle);

+0259:         empty = pa.table({})

    __pyx_t_3 = __pyx_cur_scope->__pyx_v_pa;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 259, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_1};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_table, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 259, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_empty = __pyx_t_4;
    __pyx_t_4 = 0;

+0260:         return empty.to_reader()

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __pyx_v_empty;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_reader, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 260, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

 0261: 

 0262:     # Pin the sequence after the first batch: a pre-delivery failover

 0263:     # replays batch-0 transparently into ``first``, so only resets that

 0264:     # happen once batches are flowing can duplicate already-yielded data.

+0265:     cdef int seen_seq = cursor_handle._reset_seq

  __pyx_t_8 = __pyx_cur_scope->__pyx_v_cursor_handle->_reset_seq;
  __pyx_cur_scope->__pyx_v_seen_seq = __pyx_t_8;

+0266:     schema = first.schema

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_first, __pyx_mstate_global->__pyx_n_u_schema); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 266, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_v_schema = __pyx_t_4;
  __pyx_t_4 = 0;

 0267: 

+0268:     def _gen(compact):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_26_build_record_batch_reader_1_gen(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_26_build_record_batch_reader_1_gen = {"_gen", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_26_build_record_batch_reader_1_gen, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_26_build_record_batch_reader_1_gen(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_compact = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_gen (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_compact,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 268, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 268, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_gen", 0) < (0)) __PYX_ERR(2, 268, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_gen", 1, 1, 1, i); __PYX_ERR(2, 268, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 268, __pyx_L3_error)
    }
    __pyx_v_compact = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_gen", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 268, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client._build_record_batch_reader._gen", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_26_build_record_batch_reader__gen(__pyx_self, __pyx_v_compact);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_26_build_record_batch_reader__gen(PyObject *__pyx_self, PyObject *__pyx_v_compact) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_1__gen *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_1__gen *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct_1__gen(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct_1__gen, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct_1__gen *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 268, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader *) __Pyx_CyFunction_GetClosure(__pyx_self);
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_v_compact = __pyx_v_compact;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_compact);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_compact);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7questdb_7_client_26_build_record_batch_reader_2generator2, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_gen, __pyx_mstate_global->__pyx_n_u_build_record_batch_reader_local, __pyx_mstate_global->__pyx_n_u_questdb__client); if (unlikely(!gen)) __PYX_ERR(2, 268, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("questdb._client._build_record_batch_reader._gen", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_7questdb_7_client_26_build_record_batch_reader_2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_gen", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(2, 268, __pyx_L1_error)
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("_gen", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_26_build_record_batch_reader_1_gen, 0, __pyx_mstate_global->__pyx_n_u_build_record_batch_reader_local, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 268, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_v__gen = __pyx_t_4;
  __pyx_t_4 = 0;
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct_1__gen {
  PyObject_HEAD
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct____pyx_f_7questdb_7_client__build_record_batch_reader *__pyx_outer_scope;
  PyObject *__pyx_v_compact;
  PyObject *__pyx_v_nxt;
};

+0269:         try:

  /*try:*/ {

+0270:             yield first

    if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_first)) { __Pyx_RaiseClosureNameError("first"); __PYX_ERR(2, 270, __pyx_L5_error) }
    __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_first);
    __pyx_r = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_first;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L7_resume_from_yield:;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 270, __pyx_L5_error)

+0271:             while True:

    while (1) {

+0272:                 nxt = _fetch_one_batch(cursor_handle, pa, compact)

      if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle)) { __Pyx_RaiseClosureNameError("cursor_handle"); __PYX_ERR(2, 272, __pyx_L5_error) }
      __pyx_t_1 = ((PyObject *)__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle);
      __Pyx_INCREF(__pyx_t_1);
      if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_pa)) { __Pyx_RaiseClosureNameError("pa"); __PYX_ERR(2, 272, __pyx_L5_error) }
      __pyx_t_2 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_pa;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_compact); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 272, __pyx_L5_error)
      __pyx_t_5.__pyx_n = 1;
      __pyx_t_5.compact = __pyx_t_3;
      __pyx_t_4 = __pyx_f_7questdb_7_client__fetch_one_batch(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1), __pyx_t_2, &__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 272, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_nxt);
      __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_nxt, __pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_4);
      __pyx_t_4 = 0;

+0273:                 if cursor_handle._reset_seq != seen_seq:

      if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle)) { __Pyx_RaiseClosureNameError("cursor_handle"); __PYX_ERR(2, 273, __pyx_L5_error) }
      __pyx_t_3 = (__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle->_reset_seq != __pyx_cur_scope->__pyx_outer_scope->__pyx_v_seen_seq);
      if (unlikely(__pyx_t_3)) {
/* … */
      }

 0274:                     # Mid-query failover after batches were already

 0275:                     # yielded: the replayed batch-0 would duplicate what

 0276:                     # the consumer holds. Streaming can't discard it, so

 0277:                     # surface a clean, catchable error.

+0278:                     raise QuestDBError(

        __pyx_t_2 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 278, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_1);

+0279:                         QuestDBErrorCode.FailoverWouldDuplicate,

        __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 279, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_FailoverWouldDuplicate); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 279, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_7);
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_8 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_1))) {
          __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
          assert(__pyx_t_2);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
          __Pyx_INCREF(__pyx_t_2);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
          __pyx_t_8 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_7, __pyx_mstate_global->__pyx_kp_u_mid_query_failover_would_duplica};
          __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 278, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __PYX_ERR(2, 278, __pyx_L5_error)

 0280:                         'mid-query failover would duplicate already-'

 0281:                         'delivered batches; re-issue the query')

+0282:                 if nxt is None:

      __pyx_t_3 = (__pyx_cur_scope->__pyx_v_nxt == Py_None);
      if (__pyx_t_3) {
/* … */
      }

 0283:                     # Reached terminal cleanly; reader is reusable.

+0284:                     _mark_reader_drained(cursor_handle)

        if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle)) { __Pyx_RaiseClosureNameError("cursor_handle"); __PYX_ERR(2, 284, __pyx_L5_error) }
        __pyx_t_4 = ((PyObject *)__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle);
        __Pyx_INCREF(__pyx_t_4);
        __pyx_f_7questdb_7_client__mark_reader_drained(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_4));
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+0285:                     return

        __Pyx_XDECREF(__pyx_r);
        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
        goto __pyx_L4_return;

+0286:                 yield nxt

      __Pyx_INCREF(__pyx_cur_scope->__pyx_v_nxt);
      __pyx_r = __pyx_cur_scope->__pyx_v_nxt;
      __Pyx_XGIVEREF(__pyx_r);
      __Pyx_RefNannyFinishContext();
      __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
      /* return from generator, yielding value */
      __pyx_generator->resume_label = 2;
      return __pyx_r;
      __pyx_L12_resume_from_yield:;
      if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 286, __pyx_L5_error)
    }
  }

 0287:         finally:

+0288:             cursor_handle._free()

  /*finally:*/ {
    /*normal exit:*/{
      if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle)) { __Pyx_RaiseClosureNameError("cursor_handle"); __PYX_ERR(2, 288, __pyx_L1_error) }
      ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle->__pyx_vtab)->_free(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle);
      goto __pyx_L6;
    }
    __pyx_L5_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_assign
      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
       __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
      if ( unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
      __Pyx_XGOTREF(__pyx_t_12);
      __Pyx_XGOTREF(__pyx_t_13);
      __Pyx_XGOTREF(__pyx_t_14);
      __Pyx_XGOTREF(__pyx_t_15);
      __Pyx_XGOTREF(__pyx_t_16);
      __Pyx_XGOTREF(__pyx_t_17);
      __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
      {
        if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle)) { __Pyx_RaiseClosureNameError("cursor_handle"); __PYX_ERR(2, 288, __pyx_L14_error) }
        ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle->__pyx_vtab)->_free(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle);
      }
      __Pyx_XGIVEREF(__pyx_t_15);
      __Pyx_XGIVEREF(__pyx_t_16);
      __Pyx_XGIVEREF(__pyx_t_17);
      __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_XGIVEREF(__pyx_t_13);
      __Pyx_XGIVEREF(__pyx_t_14);
      __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14);
      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
      __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
      goto __pyx_L1_error;
      __pyx_L14_error:;
      __Pyx_XGIVEREF(__pyx_t_15);
      __Pyx_XGIVEREF(__pyx_t_16);
      __Pyx_XGIVEREF(__pyx_t_17);
      __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
      __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L4_return: {
      __pyx_t_17 = __pyx_r;
      __pyx_r = 0;
      if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle)) { __Pyx_RaiseClosureNameError("cursor_handle"); __PYX_ERR(2, 288, __pyx_L1_error) }
      ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle->__pyx_vtab)->_free(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_cursor_handle);
      __pyx_r = __pyx_t_17;
      __pyx_t_17 = 0;
      goto __pyx_L0;
    }
    __pyx_L6:;
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

 0289: 

+0290:     return pa.RecordBatchReader.from_batches(schema, _gen(compact))

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_RecordBatchReader); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 290, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_compact); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 290, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_10 = __pyx_pf_7questdb_7_client_26_build_record_batch_reader__gen(__pyx_v__gen, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 290, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_7 = 0;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_schema, __pyx_t_10};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_batches, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 290, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 0291: 

 0292: 

+0293: cdef void _mark_reader_drained(_CursorHandle cursor_handle) noexcept:

static void __pyx_f_7questdb_7_client__mark_reader_drained(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_cursor_handle) {
  struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_reader = 0;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_reader);
  __Pyx_RefNannyFinishContext();
}

 0294:     """Tell the reader handle it's safe to return to its pool on dealloc.

 0295: 

 0296:     The Rust Cursor::Drop closes the underlying transport whenever

 0297:     ``cursor_active`` is still set. Only call this once the cursor has

 0298:     reached its terminal frame (``_end``) — otherwise the next pool

 0299:     borrower would see a broken pipe.

 0300:     """

+0301:     if cursor_handle is None:

  __pyx_t_1 = (((PyObject *)__pyx_v_cursor_handle) == Py_None);
  if (__pyx_t_1) {
/* … */
  }

+0302:         return

    goto __pyx_L0;

+0303:     cdef _ReaderHandle reader = cursor_handle._reader_ref

  __pyx_t_2 = ((PyObject *)__pyx_v_cursor_handle->_reader_ref);
  __Pyx_INCREF(__pyx_t_2);
  __pyx_v_reader = ((struct __pyx_obj_7questdb_7_client__ReaderHandle *)__pyx_t_2);
  __pyx_t_2 = 0;

+0304:     if reader is not None:

  __pyx_t_1 = (((PyObject *)__pyx_v_reader) != Py_None);
  if (__pyx_t_1) {
/* … */
  }

+0305:         reader._must_close = False

    __pyx_v_reader->_must_close = 0;

 0306: 

 0307: 

+0308: cdef void_int _drain_cursor(_CursorHandle handle) except -1:

static __pyx_t_7questdb_7_client_void_int __pyx_f_7questdb_7_client__drain_cursor(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle) {
  struct qwp_reader_cursor *__pyx_v_cursor;
  questdb_error *__pyx_v_err;
  struct qwp_reader_batch const *__pyx_v_batch;
  __pyx_t_7questdb_7_client_void_int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("questdb._client._drain_cursor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0309:     cdef qwp_reader_cursor* cursor

+0310:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 0311:     cdef const qwp_reader_batch* batch

+0312:     while True:

  while (1) {

+0313:         with handle._lock:

    /*with:*/ {
      __pyx_t_1 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 313, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = NULL;
      __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 313, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_5 = 1;
      #if CYTHON_UNPACK_METHODS
      if (likely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_5 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
        __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 313, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      /*try:*/ {
        {
          /*try:*/ {
/* … */
          }
          __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          goto __pyx_L18_try_end;
          __pyx_L11_error:;
          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          /*except:*/ {
            __Pyx_AddTraceback("questdb._client._drain_cursor", __pyx_clineno, __pyx_lineno, __pyx_filename);
            if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_12) < 0) __PYX_ERR(2, 313, __pyx_L13_except_error)
            __Pyx_XGOTREF(__pyx_t_2);
            __Pyx_XGOTREF(__pyx_t_3);
            __Pyx_XGOTREF(__pyx_t_12);
            __pyx_t_4 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_3, __pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 313, __pyx_L13_except_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 313, __pyx_L13_except_error)
            __Pyx_GOTREF(__pyx_t_13);
            __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_13);
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            if (__pyx_t_10 < (0)) __PYX_ERR(2, 313, __pyx_L13_except_error)
            __pyx_t_14 = (!__pyx_t_10);
            if (unlikely(__pyx_t_14)) {
              __Pyx_GIVEREF(__pyx_t_2);
              __Pyx_GIVEREF(__pyx_t_3);
              __Pyx_XGIVEREF(__pyx_t_12);
              __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_3, __pyx_t_12);
              __pyx_t_2 = 0;  __pyx_t_3 = 0;  __pyx_t_12 = 0; 
              __PYX_ERR(2, 313, __pyx_L13_except_error)
            }
            __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
            goto __pyx_L12_exception_handled;
          }
          __pyx_L13_except_error:;
          __Pyx_XGIVEREF(__pyx_t_6);
          __Pyx_XGIVEREF(__pyx_t_7);
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
          goto __pyx_L1_error;
          __pyx_L12_exception_handled:;
          __Pyx_XGIVEREF(__pyx_t_6);
          __Pyx_XGIVEREF(__pyx_t_7);
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
          __pyx_L18_try_end:;
        }
      }
      /*finally:*/ {
        /*normal exit:*/{
          if (__pyx_t_1) {
            __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[2], NULL);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 313, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          }
          goto __pyx_L10;
        }
        __pyx_L10:;
      }
      goto __pyx_L28;
      __pyx_L5_error:;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L1_error;
      __pyx_L28:;
    }

+0314:             cursor = handle._cursor

            __pyx_t_9 = __pyx_v_handle->_cursor;
            __pyx_v_cursor = __pyx_t_9;

+0315:             if cursor == NULL:

            __pyx_t_10 = (__pyx_v_cursor == NULL);
            if (unlikely(__pyx_t_10)) {
/* … */
            }

+0316:                 raise QuestDBError(

              __pyx_t_4 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 316, __pyx_L11_error)
              __Pyx_GOTREF(__pyx_t_3);

+0317:                     QuestDBErrorCode.InvalidApiCall, 'cursor is closed')

              __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 317, __pyx_L11_error)
              __Pyx_GOTREF(__pyx_t_11);
              __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 317, __pyx_L11_error)
              __Pyx_GOTREF(__pyx_t_12);
              __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
              __pyx_t_5 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_3))) {
                __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
                assert(__pyx_t_4);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
                __Pyx_INCREF(__pyx_t_4);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
                __pyx_t_5 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_12, __pyx_mstate_global->__pyx_kp_u_cursor_is_closed};
                __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
                __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
                if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 316, __pyx_L11_error)
                __Pyx_GOTREF(__pyx_t_2);
              }
              __Pyx_Raise(__pyx_t_2, 0, 0, 0);
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              __PYX_ERR(2, 316, __pyx_L11_error)

+0318:             with nogil:

            {
                PyThreadState * _save;
                _save = PyEval_SaveThread();
                __Pyx_FastGIL_Remember();
                /*try:*/ {
/* … */
                /*finally:*/ {
                  /*normal exit:*/{
                    __Pyx_FastGIL_Forget();
                    PyEval_RestoreThread(_save);
                    goto __pyx_L24;
                  }
                  __pyx_L24:;
                }
            }

+0319:                 batch = qwp_reader_cursor_next_batch(cursor, &err)

                  __pyx_v_batch = qwp_reader_cursor_next_batch(__pyx_v_cursor, (&__pyx_v_err));
                }

+0320:         if batch == NULL:

    __pyx_t_14 = (__pyx_v_batch == NULL);
    if (__pyx_t_14) {
/* … */
    }
  }
  __pyx_L4_break:;

+0321:             if err != NULL:

      __pyx_t_14 = (__pyx_v_err != NULL);
      if (unlikely(__pyx_t_14)) {
/* … */
      }

+0322:                 raise _reader_err_to_py(err)

        __pyx_t_12 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 322, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_Raise(__pyx_t_12, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __PYX_ERR(2, 322, __pyx_L1_error)

+0323:             break

      goto __pyx_L4_break;

+0324:     _mark_reader_drained(handle)

  __pyx_f_7questdb_7_client__mark_reader_drained(__pyx_v_handle);

+0325:     handle._free()

  ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_handle->__pyx_vtab)->_free(__pyx_v_handle);

 0326: 

 0327: 

+0328: cdef _ReaderHandle _borrow_reader_from_pool(questdb_db* db):

static struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_f_7questdb_7_client__borrow_reader_from_pool(struct questdb_db *__pyx_v_db) {
  questdb_error *__pyx_v_err;
  struct qwp_reader *__pyx_v_reader;
  struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_handle = 0;
  struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("questdb._client._borrow_reader_from_pool", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0329:     """Borrow a reader from the Rust-side ``questdb_db`` pool.

 0330: 

 0331:     Wraps ``questdb_db_borrow_reader`` and packs the result into a

 0332:     :class:`_ReaderHandle` that knows it came from this pool, so

 0333:     its dealloc returns/drops via the matching FFI.

 0334:     """

+0335:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

+0336:     cdef qwp_reader* reader = NULL

  __pyx_v_reader = NULL;

+0337:     with nogil:

  {
      PyThreadState * _save;
      _save = PyEval_SaveThread();
      __Pyx_FastGIL_Remember();
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          __Pyx_FastGIL_Forget();
          PyEval_RestoreThread(_save);
          goto __pyx_L5;
        }
        __pyx_L5:;
      }
  }

+0338:         reader = questdb_db_borrow_reader(db, &err)

        __pyx_v_reader = questdb_db_borrow_reader(__pyx_v_db, (&__pyx_v_err));
      }

+0339:     if reader == NULL:

  __pyx_t_1 = (__pyx_v_reader == NULL);
  if (__pyx_t_1) {
/* … */
  }

+0340:         if err == NULL:

    __pyx_t_1 = (__pyx_v_err == NULL);
    if (unlikely(__pyx_t_1)) {
/* … */
    }

+0341:             raise QuestDBError(

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 341, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);

+0342:                 QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 342, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 342, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_7 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_7 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_6, __pyx_mstate_global->__pyx_kp_u_questdb_db_borrow_reader_returne};
        __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 341, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_Raise(__pyx_t_2, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __PYX_ERR(2, 341, __pyx_L1_error)

 0343:                 'questdb_db_borrow_reader returned NULL without setting err')

+0344:         raise _reader_err_to_py(err)

    __pyx_t_2 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 344, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 344, __pyx_L1_error)

 0345:     cdef _ReaderHandle handle

+0346:     try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    goto __pyx_L13_try_end;
    __pyx_L8_error:;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* … */
    __pyx_L10_except_error:;
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_XGIVEREF(__pyx_t_9);
    __Pyx_XGIVEREF(__pyx_t_10);
    __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
    goto __pyx_L1_error;
    __pyx_L13_try_end:;
  }

+0347:         handle = _ReaderHandle()

      __pyx_t_4 = NULL;
      __pyx_t_7 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
        __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_7questdb_7_client__ReaderHandle, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 347, __pyx_L8_error)
        __Pyx_GOTREF((PyObject *)__pyx_t_2);
      }
      __pyx_v_handle = ((struct __pyx_obj_7questdb_7_client__ReaderHandle *)__pyx_t_2);
      __pyx_t_2 = 0;

+0348:     except:

    /*except:*/ {
      __Pyx_AddTraceback("questdb._client._borrow_reader_from_pool", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(2, 348, __pyx_L10_except_error)
      __Pyx_XGOTREF(__pyx_t_2);
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_XGOTREF(__pyx_t_6);

+0349:         with nogil:

      {
          PyThreadState * _save;
          _save = PyEval_SaveThread();
          __Pyx_FastGIL_Remember();
          /*try:*/ {
/* … */
          /*finally:*/ {
            /*normal exit:*/{
              __Pyx_FastGIL_Forget();
              PyEval_RestoreThread(_save);
              goto __pyx_L20;
            }
            __pyx_L20:;
          }
      }

+0350:             qwp_reader_close(reader)

            qwp_reader_close(__pyx_v_reader);
          }

+0351:         raise

      __Pyx_GIVEREF(__pyx_t_2);
      __Pyx_GIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_4, __pyx_t_6);
      __pyx_t_2 = 0;  __pyx_t_4 = 0;  __pyx_t_6 = 0; 
      __PYX_ERR(2, 351, __pyx_L10_except_error)
    }

+0352:     handle._attach(reader)

  __pyx_t_6 = ((struct __pyx_vtabstruct_7questdb_7_client__ReaderHandle *)__pyx_v_handle->__pyx_vtab)->_attach(__pyx_v_handle, __pyx_v_reader); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 0353:     # A freshly borrowed reader is pristine: recycle it unless a query

 0354:     # arms _must_close at the network boundary (_execute_query).

+0355:     handle._must_close = False

  __pyx_v_handle->_must_close = 0;

+0356:     return handle

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_handle);
  __pyx_r = __pyx_v_handle;
  goto __pyx_L0;

 0357: 

 0358: 

+0359: cdef object _snapshot_server_info(_ReaderHandle handle):

static PyObject *__pyx_f_7questdb_7_client__snapshot_server_info(struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_handle) {
  struct qwp_reader_server_info const *__pyx_v_si;
  char const *__pyx_v_buf;
  size_t __pyx_v_buf_len;
  int __pyx_v_role_int;
  PyObject *__pyx_v_role = NULL;
  PyObject *__pyx_v_entry = NULL;
  uint8_t __pyx_v_role_byte;
  uint64_t __pyx_v_epoch;
  uint32_t __pyx_v_capabilities;
  int64_t __pyx_v_server_wall_ns;
  PyObject *__pyx_v_cluster_id = NULL;
  PyObject *__pyx_v_node_id = NULL;
  PyObject *__pyx_v_zone_id = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("questdb._client._snapshot_server_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_role);
  __Pyx_XDECREF(__pyx_v_entry);
  __Pyx_XDECREF(__pyx_v_cluster_id);
  __Pyx_XDECREF(__pyx_v_node_id);
  __Pyx_XDECREF(__pyx_v_zone_id);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0360:     """Copy the reader's last-seen ``SERVER_INFO`` into a :class:`ServerInfo`.

 0361: 

 0362:     The FFI pointer is borrowed and invalidated by any reader operation

 0363:     that may reconnect, so every field is copied out before returning.

 0364:     """

 0365:     cdef const qwp_reader_server_info* si = \

+0366:         qwp_reader_current_server_info(handle._reader)

  __pyx_v_si = qwp_reader_current_server_info(__pyx_v_handle->_reader);

+0367:     cdef const char* buf = NULL

  __pyx_v_buf = NULL;

+0368:     cdef size_t buf_len = 0

  __pyx_v_buf_len = 0;

+0369:     if si == NULL:

  __pyx_t_1 = (__pyx_v_si == NULL);
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+0370:         raise QuestDBError(

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 370, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+0371:             QuestDBErrorCode.SocketError,

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 371, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_SocketError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 371, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_6, __pyx_mstate_global->__pyx_kp_u_SERVER_INFO_unavailable_the_conn};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 370, __pyx_L1_error)

 0372:             'SERVER_INFO unavailable: the connection is mid-reconnect.')

+0373:     cdef int role_int = <int>qwp_reader_server_info_role(si)

  __pyx_v_role_int = ((int)qwp_reader_server_info_role(__pyx_v_si));

+0374:     role = ServerRole.Other

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ServerRole); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Other); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_role = __pyx_t_4;
  __pyx_t_4 = 0;

+0375:     for entry in ServerRole:

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ServerRole); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 375, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
    __pyx_t_2 = __pyx_t_4; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_8 = 0;
    __pyx_t_9 = NULL;
  } else {
    __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 375, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 375, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  for (;;) {
    if (likely(!__pyx_t_9)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 375, __pyx_L1_error)
          #endif
          if (__pyx_t_8 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_8, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_8;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 375, __pyx_L1_error)
          #endif
          if (__pyx_t_8 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_8);
        #endif
        ++__pyx_t_8;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 375, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_9(__pyx_t_2);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 375, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  goto __pyx_L7_for_end;
  __pyx_L5_break:;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  goto __pyx_L7_for_end;
  __pyx_L7_for_end:;

+0376:         if entry.c_value == role_int:

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_entry, __pyx_mstate_global->__pyx_n_u_c_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 376, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_role_int); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 376, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 376, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(2, 376, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (__pyx_t_1) {
/* … */
    }

+0377:             role = entry

      __Pyx_INCREF(__pyx_v_entry);
      __Pyx_DECREF_SET(__pyx_v_role, __pyx_v_entry);

+0378:             break

      goto __pyx_L5_break;

+0379:     cdef uint8_t role_byte = qwp_reader_server_info_role_byte(si)

  __pyx_v_role_byte = qwp_reader_server_info_role_byte(__pyx_v_si);

+0380:     cdef uint64_t epoch = qwp_reader_server_info_epoch(si)

  __pyx_v_epoch = qwp_reader_server_info_epoch(__pyx_v_si);

+0381:     cdef uint32_t capabilities = qwp_reader_server_info_capabilities(si)

  __pyx_v_capabilities = qwp_reader_server_info_capabilities(__pyx_v_si);

+0382:     cdef int64_t server_wall_ns = qwp_reader_server_info_server_wall_ns(si)

  __pyx_v_server_wall_ns = qwp_reader_server_info_server_wall_ns(__pyx_v_si);

+0383:     qwp_reader_server_info_cluster_id(si, &buf, &buf_len)

  qwp_reader_server_info_cluster_id(__pyx_v_si, (&__pyx_v_buf), (&__pyx_v_buf_len));

+0384:     cluster_id = PyUnicode_FromStringAndSize(buf, <Py_ssize_t>buf_len) \

    __pyx_t_3 = PyUnicode_FromStringAndSize(__pyx_v_buf, ((Py_ssize_t)__pyx_v_buf_len)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 384, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __pyx_t_3;
    __pyx_t_3 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__7);
    __pyx_t_2 = __pyx_mstate_global->__pyx_kp_u__7;
  }
  __pyx_v_cluster_id = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+0385:         if buf != NULL else ''

  __pyx_t_1 = (__pyx_v_buf != NULL);
  if (__pyx_t_1) {

+0386:     buf = NULL

  __pyx_v_buf = NULL;

+0387:     buf_len = 0

  __pyx_v_buf_len = 0;

+0388:     qwp_reader_server_info_node_id(si, &buf, &buf_len)

  qwp_reader_server_info_node_id(__pyx_v_si, (&__pyx_v_buf), (&__pyx_v_buf_len));

+0389:     node_id = PyUnicode_FromStringAndSize(buf, <Py_ssize_t>buf_len) \

    __pyx_t_3 = PyUnicode_FromStringAndSize(__pyx_v_buf, ((Py_ssize_t)__pyx_v_buf_len)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __pyx_t_3;
    __pyx_t_3 = 0;
  } else {
    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__7);
    __pyx_t_2 = __pyx_mstate_global->__pyx_kp_u__7;
  }
  __pyx_v_node_id = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+0390:         if buf != NULL else ''

  __pyx_t_1 = (__pyx_v_buf != NULL);
  if (__pyx_t_1) {

+0391:     buf = NULL

  __pyx_v_buf = NULL;

+0392:     buf_len = 0

  __pyx_v_buf_len = 0;

+0393:     zone_id = None

  __Pyx_INCREF(Py_None);
  __pyx_v_zone_id = ((PyObject*)Py_None);

+0394:     if qwp_reader_server_info_zone_id(si, &buf, &buf_len):

  __pyx_t_1 = qwp_reader_server_info_zone_id(__pyx_v_si, (&__pyx_v_buf), (&__pyx_v_buf_len));
  if (__pyx_t_1) {
/* … */
  }

+0395:         zone_id = PyUnicode_FromStringAndSize(buf, <Py_ssize_t>buf_len) \

      __pyx_t_3 = PyUnicode_FromStringAndSize(__pyx_v_buf, ((Py_ssize_t)__pyx_v_buf_len)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 395, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_2 = __pyx_t_3;
      __pyx_t_3 = 0;
    } else {
      __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__7);
      __pyx_t_2 = __pyx_mstate_global->__pyx_kp_u__7;
    }
    __Pyx_DECREF_SET(__pyx_v_zone_id, ((PyObject*)__pyx_t_2));
    __pyx_t_2 = 0;

+0396:             if buf != NULL else ''

    __pyx_t_1 = (__pyx_v_buf != NULL);
    if (__pyx_t_1) {

+0397:     return ServerInfo(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ServerInfo); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);

 0398:         role=role,

+0399:         role_byte=role_byte,

  __pyx_t_4 = __Pyx_PyLong_From_uint8_t(__pyx_v_role_byte); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 399, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+0400:         epoch=epoch,

  __pyx_t_5 = __Pyx_PyLong_From_uint64_t(__pyx_v_epoch); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 400, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+0401:         capabilities=capabilities,

  __pyx_t_10 = __Pyx_PyLong_From_uint32_t(__pyx_v_capabilities); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 401, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);

+0402:         server_wall_ns=server_wall_ns,

  __pyx_t_11 = __Pyx_PyLong_From_int64_t(__pyx_v_server_wall_ns); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 402, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);

 0403:         cluster_id=cluster_id,

 0404:         node_id=node_id,

+0405:         zone_id=zone_id)

  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 8 : 0)] = {__pyx_t_3, NULL};
    __pyx_t_12 = __Pyx_MakeVectorcallBuilderKwds(8); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 397, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_role, __pyx_v_role, __pyx_t_12, __pyx_callargs+1, 0) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_role_byte, __pyx_t_4, __pyx_t_12, __pyx_callargs+1, 1) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_epoch, __pyx_t_5, __pyx_t_12, __pyx_callargs+1, 2) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_capabilities, __pyx_t_10, __pyx_t_12, __pyx_callargs+1, 3) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_server_wall_ns, __pyx_t_11, __pyx_t_12, __pyx_callargs+1, 4) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_cluster_id, __pyx_v_cluster_id, __pyx_t_12, __pyx_callargs+1, 5) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_node_id, __pyx_v_node_id, __pyx_t_12, __pyx_callargs+1, 6) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_zone_id, __pyx_v_zone_id, __pyx_t_12, __pyx_callargs+1, 7) < (0)) __PYX_ERR(2, 397, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_12);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 397, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 0406: 

 0407: 

+0408: cdef void _failover_reset_trampoline(

static void __pyx_f_7questdb_7_client__failover_reset_trampoline(CYTHON_UNUSED struct qwp_reader_failover_reset_event const *__pyx_v_event, void *__pyx_v_user_data) {
/* … */
  /* function exit code */
  __pyx_L0:;
}

 0409:         const qwp_reader_failover_reset_event* event,

 0410:         void* user_data) noexcept nogil:

 0411:     # Fires synchronously inside qwp_reader_cursor_next_batch while the

 0412:     # reader re-executes on a new endpoint, before the replayed batch-0

 0413:     # arrives. Honour the C reentrancy contract: no reentrant FFI on the

 0414:     # reader/query/cursor, no exception escapes, non-blocking. user_data is

 0415:     # a raw int* at the cursor's _reset_seq counter; bumping it is a plain

 0416:     # pointer write (no GIL, no Python object touched), which the

 0417:     # materialise-whole accumulator polls to discard its pre-failover batches.

+0418:     if user_data == NULL:

  __pyx_t_1 = (__pyx_v_user_data == NULL);
  if (__pyx_t_1) {
/* … */
  }

+0419:         return

    goto __pyx_L0;

+0420:     (<int*>user_data)[0] += 1

  __pyx_t_2 = ((int *)__pyx_v_user_data);
  __pyx_t_3 = 0;
  (__pyx_t_2[__pyx_t_3]) = ((__pyx_t_2[__pyx_t_3]) + 1);

 0421: 

 0422: 

+0423: cdef void_int _bind_query_params(qwp_reader_query* query, object binds) except -1:

static __pyx_t_7questdb_7_client_void_int __pyx_f_7questdb_7_client__bind_query_params(struct qwp_reader_query *__pyx_v_query, PyObject *__pyx_v_binds) {
  PyObject *__pyx_v_utf8 = 0;
  PyObject *__pyx_v_uuid_wire = 0;
  struct line_sender_utf8 __pyx_v_c_utf8;
  struct line_sender_error *__pyx_v_utf8_err;
  PyObject *__pyx_v_u_int = 0;
  Py_ssize_t __pyx_v_idx;
  PyObject *__pyx_v_value = NULL;
  __pyx_t_7questdb_7_client_void_int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("questdb._client._bind_query_params", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_utf8);
  __Pyx_XDECREF(__pyx_v_uuid_wire);
  __Pyx_XDECREF(__pyx_v_u_int);
  __Pyx_XDECREF(__pyx_v_value);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0424:     """Append positional binds matching the SQL's ``$1``..``$N`` placeholders.

 0425: 

 0426:     Bind calls follow the C ABI's deferred-error contract (they return

 0427:     void; the only native-side failure surfaces from execute), so the only

 0428:     errors raised here are Python-side type rejections.

 0429:     """

 0430:     cdef bytes utf8

 0431:     cdef bytes uuid_wire

 0432:     cdef line_sender_utf8 c_utf8

+0433:     cdef line_sender_error* utf8_err = NULL

  __pyx_v_utf8_err = NULL;

 0434:     cdef object u_int

+0435:     cdef Py_ssize_t idx = 0

  __pyx_v_idx = 0;

+0436:     for value in binds:

  if (likely(PyList_CheckExact(__pyx_v_binds)) || PyTuple_CheckExact(__pyx_v_binds)) {
    __pyx_t_1 = __pyx_v_binds; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_binds); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 436, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 436, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 436, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 436, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 436, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 436, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+0437:         idx += 1

    __pyx_v_idx = (__pyx_v_idx + 1);

+0438:         if value is None:

    __pyx_t_5 = (__pyx_v_value == Py_None);
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0439:             qwp_reader_query_bind_null_varchar(query)

      qwp_reader_query_bind_null_varchar(__pyx_v_query);

+0440:         elif value is True or value is False:

    __pyx_t_6 = (__pyx_v_value == Py_True);
    if (!__pyx_t_6) {
    } else {
      __pyx_t_5 = __pyx_t_6;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_6 = (__pyx_v_value == Py_False);
    __pyx_t_5 = __pyx_t_6;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0441:             qwp_reader_query_bind_bool(query, value)

      __pyx_t_7 = __Pyx_PyLong_As_bool(__pyx_v_value); if (unlikely((__pyx_t_7 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(2, 441, __pyx_L1_error)
      qwp_reader_query_bind_bool(__pyx_v_query, __pyx_t_7);

+0442:         elif isinstance(value, int):

    __pyx_t_5 = PyLong_Check(__pyx_v_value); 
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0443:             if value < INT64_MIN or value > INT64_MAX:

      __pyx_t_4 = __Pyx_PyLong_From_int64_t(INT64_MIN); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 443, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_8 = PyObject_RichCompare(__pyx_v_value, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 443, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(2, 443, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (!__pyx_t_6) {
      } else {
        __pyx_t_5 = __pyx_t_6;
        goto __pyx_L9_bool_binop_done;
      }
      __pyx_t_8 = __Pyx_PyLong_From_int64_t(INT64_MAX); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 443, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_value, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 443, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(2, 443, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_5 = __pyx_t_6;
      __pyx_L9_bool_binop_done:;
      if (unlikely(__pyx_t_5)) {
/* … */
      }

+0444:                 raise OverflowError(

        __pyx_t_8 = NULL;

+0445:                     f'query bind ${idx}: int out of the signed 64-bit '

        __pyx_t_9 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 445, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
/* … */
        __pyx_t_12 = __Pyx_PyUnicode_Join(__pyx_t_11, 4, 12 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 60 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
        if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 445, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_13 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_12};
          __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_OverflowError)), __pyx_callargs+__pyx_t_13, (2-__pyx_t_13) | (__pyx_t_13*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 444, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __PYX_ERR(2, 444, __pyx_L1_error)

+0446:                     f'range QuestDB LONG supports: {value}')

        __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 446, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_query_bind;
        __pyx_t_11[1] = __pyx_t_9;
        __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_int_out_of_the_signed_64_bit_ra;
        __pyx_t_11[3] = __pyx_t_10;

+0447:             qwp_reader_query_bind_i64(query, value)

      __pyx_t_14 = __Pyx_PyLong_As_int64_t(__pyx_v_value); if (unlikely((__pyx_t_14 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 447, __pyx_L1_error)
      qwp_reader_query_bind_i64(__pyx_v_query, __pyx_t_14);

+0448:         elif isinstance(value, float):

    __pyx_t_5 = PyFloat_Check(__pyx_v_value); 
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0449:             qwp_reader_query_bind_f64(query, value)

      __pyx_t_15 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_15 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 449, __pyx_L1_error)
      qwp_reader_query_bind_f64(__pyx_v_query, __pyx_t_15);

+0450:         elif isinstance(value, str):

    __pyx_t_5 = PyUnicode_Check(__pyx_v_value); 
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0451:             utf8 = value.encode('utf-8')

      __pyx_t_12 = __pyx_v_value;
      __Pyx_INCREF(__pyx_t_12);
      __pyx_t_13 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_utf_8};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_13, (2-__pyx_t_13) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 451, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_4))) __PYX_ERR(2, 451, __pyx_L1_error)
      __Pyx_XDECREF_SET(__pyx_v_utf8, ((PyObject*)__pyx_t_4));
      __pyx_t_4 = 0;

+0452:             if not line_sender_utf8_init(

      __pyx_t_5 = (!line_sender_utf8_init((&__pyx_v_c_utf8), ((size_t)__pyx_t_16), ((char const *)__pyx_t_17), (&__pyx_v_utf8_err)));
      if (unlikely(__pyx_t_5)) {
/* … */
      }

 0453:                     &c_utf8,

+0454:                     <size_t>len(utf8),

      if (unlikely(__pyx_v_utf8 == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
        __PYX_ERR(2, 454, __pyx_L1_error)
      }
      __pyx_t_16 = __Pyx_PyBytes_GET_SIZE(__pyx_v_utf8); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 454, __pyx_L1_error)

+0455:                     <const char*>utf8,

      if (unlikely(__pyx_v_utf8 == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
        __PYX_ERR(2, 455, __pyx_L1_error)
      }
      __pyx_t_17 = __Pyx_PyBytes_AsString(__pyx_v_utf8); if (unlikely((!__pyx_t_17) && PyErr_Occurred())) __PYX_ERR(2, 455, __pyx_L1_error)

 0456:                     &utf8_err):

+0457:                 raise c_err_to_py(utf8_err)

        __pyx_t_4 = __pyx_f_7questdb_7_client_c_err_to_py(__pyx_v_utf8_err); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 457, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __PYX_ERR(2, 457, __pyx_L1_error)

+0458:             qwp_reader_query_bind_varchar(query, c_utf8)

      qwp_reader_query_bind_varchar(__pyx_v_query, __pyx_v_c_utf8);

+0459:         elif isinstance(value, TimestampNanos):

    __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_value, __pyx_mstate_global->__pyx_ptype_7questdb_7_client_TimestampNanos); 
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0460:             qwp_reader_query_bind_timestamp_nanos(query, value.value)

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 460, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_14 = __Pyx_PyLong_As_int64_t(__pyx_t_4); if (unlikely((__pyx_t_14 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 460, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      qwp_reader_query_bind_timestamp_nanos(__pyx_v_query, __pyx_t_14);

+0461:         elif isinstance(value, TimestampMicros):

    __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_value, __pyx_mstate_global->__pyx_ptype_7questdb_7_client_TimestampMicros); 
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0462:             qwp_reader_query_bind_timestamp_micros(query, value.value)

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 462, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_14 = __Pyx_PyLong_As_int64_t(__pyx_t_4); if (unlikely((__pyx_t_14 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(2, 462, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      qwp_reader_query_bind_timestamp_micros(__pyx_v_query, __pyx_t_14);

+0463:         elif isinstance(value, datetime.datetime):

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = PyObject_IsInstance(__pyx_v_value, __pyx_t_12); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 463, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (__pyx_t_5) {
/* … */
      goto __pyx_L5;
    }

+0464:             qwp_reader_query_bind_timestamp_micros(

      qwp_reader_query_bind_timestamp_micros(__pyx_v_query, __pyx_t_14);

+0465:                 query, datetime_to_micros(value))

      if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_mstate_global->__pyx_ptype_7cpython_8datetime_datetime))))) __PYX_ERR(2, 465, __pyx_L1_error)
      __pyx_t_14 = __pyx_f_7questdb_7_client_datetime_to_micros(((PyDateTime_DateTime *)__pyx_v_value)); if (unlikely(__pyx_t_14 == ((int64_t)-1L) && PyErr_Occurred())) __PYX_ERR(2, 465, __pyx_L1_error)

+0466:         elif isinstance(value, uuid.UUID):

    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_uuid_2); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 466, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_UUID); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 466, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_5 = PyObject_IsInstance(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 466, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (likely(__pyx_t_5)) {
/* … */
      goto __pyx_L5;
    }

 0467:             # QuestDB's UUID wire layout: low 64 bits little-endian, then

 0468:             # high 64 bits little-endian (matching the ingestion side and

 0469:             # the Java client's (lo, hi) long-pair encoding).

+0470:             u_int = value.int

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_mstate_global->__pyx_n_u_int); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 470, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_u_int, __pyx_t_4);
      __pyx_t_4 = 0;

 0471:             uuid_wire = (

+0472:                 (u_int & 0xFFFFFFFFFFFFFFFF).to_bytes(8, 'little')

      __pyx_t_4 = PyNumber_And(__pyx_v_u_int, __pyx_mstate_global->__pyx_int_0xffffffffffffffff); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 472, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_to_bytes); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 472, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_mstate_global->__pyx_tuple[3], NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 472, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_little); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(2, 472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]);

+0473:                 + (u_int >> 64).to_bytes(8, 'little'))

      __pyx_t_12 = PyNumber_Rshift(__pyx_v_u_int, __pyx_mstate_global->__pyx_int_64); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 473, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_to_bytes); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 473, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_mstate_global->__pyx_tuple[3], NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 473, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = PyNumber_Add(__pyx_t_4, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 473, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (!(likely(PyBytes_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_8))) __PYX_ERR(2, 473, __pyx_L1_error)
      __Pyx_XDECREF_SET(__pyx_v_uuid_wire, ((PyObject*)__pyx_t_8));
      __pyx_t_8 = 0;

+0474:             qwp_reader_query_bind_uuid(

      qwp_reader_query_bind_uuid(__pyx_v_query, ((uint8_t const *)__pyx_t_18));

+0475:                 query, <const uint8_t*>PyBytes_AsString(uuid_wire))

      __pyx_t_18 = PyBytes_AsString(__pyx_v_uuid_wire); if (unlikely(__pyx_t_18 == ((void *)NULL))) __PYX_ERR(2, 475, __pyx_L1_error)

 0476:         else:

+0477:             raise TypeError(

    /*else*/ {
      __pyx_t_12 = NULL;

+0478:                 f'query bind ${idx}: unsupported type '

      __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
/* … */
      __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 12 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 19 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 104, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
      if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 478, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __pyx_t_13 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_10};
        __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_13, (2-__pyx_t_13) | (__pyx_t_13*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 477, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
      }
      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __PYX_ERR(2, 477, __pyx_L1_error)
    }
    __pyx_L5:;

+0479:                 f'{_fqn(type(value))}. Supported: None, bool, int, float, '

      __pyx_t_10 = __pyx_f_7questdb_7_client__fqn(((PyTypeObject*)((PyObject *)Py_TYPE(__pyx_v_value)))); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 479, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_9 = __Pyx_PyUnicode_Unicode(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 479, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_query_bind;
      __pyx_t_19[1] = __pyx_t_4;
      __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u_unsupported_type;
      __pyx_t_19[3] = __pyx_t_9;
      __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u_Supported_None_bool_int_float_s;

 0480:                 f'str, datetime.datetime, TimestampMicros, TimestampNanos, '

 0481:                 f'uuid.UUID.')

+0482:     return 0

  __pyx_r = 0;
  goto __pyx_L0;

 0483: 

 0484: 

+0485: cdef _CursorHandle _execute_query(

static struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_f_7questdb_7_client__execute_query(struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_reader_handle, PyObject *__pyx_v_sql, PyObject *__pyx_v_binds, struct __pyx_opt_args_7questdb_7_client__execute_query *__pyx_optional_args) {
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("questdb._client._execute_query", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_sql_bytes);
  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_opt_args_7questdb_7_client__execute_query {
  int __pyx_n;
  int reset_symbol_dict;
};

 0486:         _ReaderHandle reader_handle, str sql, object binds,

+0487:         bint reset_symbol_dict=True):

  int __pyx_v_reset_symbol_dict = ((int)1);
  PyObject *__pyx_v_sql_bytes = 0;
  struct line_sender_error *__pyx_v_utf8_err;
  struct line_sender_utf8 __pyx_v_sql_utf8;
  questdb_error *__pyx_v_err;
  struct qwp_reader_query *__pyx_v_query;
  struct qwp_reader_cursor *__pyx_v_cursor;
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle = 0;
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_reset_symbol_dict = __pyx_optional_args->reset_symbol_dict;
    }
  }

 0488:     """Execute a SQL query and return a _CursorHandle.

 0489: 

 0490:     The query is prepared with an ``on_failover_reset`` trampoline that

 0491:     bumps the cursor's ``_reset_seq`` on a mid-query failover. The

 0492:     materialise-whole entry points poll it to discard their partial

 0493:     accumulation and replay-from-batch-0 transparently; the streaming

 0494:     entry points poll it to surface a clean ``FailoverWouldDuplicate``

 0495:     (the already-yielded batches can't be discarded). Installing the

 0496:     callback also clears the C-side silent-duplicate guard, so a

 0497:     post-delivery failover re-executes rather than aborting outright.

 0498:     """

+0499:     cdef bytes sql_bytes = sql.encode('utf-8')

  if (unlikely(__pyx_v_sql == Py_None)) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode");
    __PYX_ERR(2, 499, __pyx_L1_error)
  }
  __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_sql); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 499, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_sql_bytes = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+0500:     cdef line_sender_error* utf8_err = NULL

  __pyx_v_utf8_err = NULL;

 0501:     cdef line_sender_utf8 sql_utf8

+0502:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 0503:     cdef qwp_reader_query* query

 0504:     cdef qwp_reader_cursor* cursor

 0505: 

+0506:     if not line_sender_utf8_init(

  __pyx_t_4 = (!line_sender_utf8_init((&__pyx_v_sql_utf8), ((size_t)__pyx_t_2), ((char const *)((char *)__pyx_t_3)), (&__pyx_v_utf8_err)));
  if (unlikely(__pyx_t_4)) {
/* … */
  }

 0507:             &sql_utf8,

+0508:             <size_t>len(sql_bytes),

  __pyx_t_2 = __Pyx_PyBytes_GET_SIZE(__pyx_v_sql_bytes); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(2, 508, __pyx_L1_error)

+0509:             <const char*><char*>sql_bytes,

  __pyx_t_3 = __Pyx_PyBytes_AsWritableString(__pyx_v_sql_bytes); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(2, 509, __pyx_L1_error)

 0510:             &utf8_err):

+0511:         raise c_err_to_py(utf8_err)

    __pyx_t_1 = __pyx_f_7questdb_7_client_c_err_to_py(__pyx_v_utf8_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 511, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 511, __pyx_L1_error)

 0512: 

+0513:     cdef _CursorHandle handle = _CursorHandle()

  __pyx_t_5 = NULL;
  __pyx_t_6 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 513, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_v_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1);
  __pyx_t_1 = 0;

 0514: 

+0515:     with nogil:

  {
      PyThreadState * _save;
      _save = PyEval_SaveThread();
      __Pyx_FastGIL_Remember();
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          __Pyx_FastGIL_Forget();
          PyEval_RestoreThread(_save);
          goto __pyx_L6;
        }
        __pyx_L6:;
      }
  }

+0516:         query = qwp_reader_prepare(reader_handle._reader, sql_utf8, &err)

        __pyx_v_query = qwp_reader_prepare(__pyx_v_reader_handle->_reader, __pyx_v_sql_utf8, (&__pyx_v_err));
      }

 0517: 

+0518:     if query == NULL:

  __pyx_t_4 = (__pyx_v_query == NULL);
  if (__pyx_t_4) {
/* … */
  }

+0519:         if err == NULL:

    __pyx_t_4 = (__pyx_v_err == NULL);
    if (unlikely(__pyx_t_4)) {
/* … */
    }

+0520:             raise QuestDBError(

      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 520, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);

+0521:                 QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 521, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 521, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_9, __pyx_mstate_global->__pyx_kp_u_qwp_reader_prepare_returned_NULL};
        __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 520, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_Raise(__pyx_t_1, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __PYX_ERR(2, 520, __pyx_L1_error)

 0522:                 'qwp_reader_prepare returned NULL without setting err')

+0523:         raise _reader_err_to_py(err)

    __pyx_t_1 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 523, __pyx_L1_error)

 0524: 

+0525:     if binds is not None:

  __pyx_t_4 = (__pyx_v_binds != Py_None);
  if (__pyx_t_4) {
/* … */
  }

+0526:         try:

    {
      /*try:*/ {
/* … */
      }
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      goto __pyx_L15_try_end;
      __pyx_L10_error:;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
      __pyx_L12_except_error:;
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
      goto __pyx_L1_error;
      __pyx_L15_try_end:;
    }

+0527:             _bind_query_params(query, binds)

        __pyx_t_13 = __pyx_f_7questdb_7_client__bind_query_params(__pyx_v_query, __pyx_v_binds); if (unlikely(__pyx_t_13 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 527, __pyx_L10_error)

+0528:         except:

      /*except:*/ {
        __Pyx_AddTraceback("questdb._client._execute_query", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_9) < 0) __PYX_ERR(2, 528, __pyx_L12_except_error)
        __Pyx_XGOTREF(__pyx_t_1);
        __Pyx_XGOTREF(__pyx_t_7);
        __Pyx_XGOTREF(__pyx_t_9);

+0529:             qwp_reader_query_free(query)

        qwp_reader_query_free(__pyx_v_query);

+0530:             raise

        __Pyx_GIVEREF(__pyx_t_1);
        __Pyx_GIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_7, __pyx_t_9);
        __pyx_t_1 = 0;  __pyx_t_7 = 0;  __pyx_t_9 = 0; 
        __PYX_ERR(2, 530, __pyx_L12_except_error)
      }

 0531: 

+0532:     qwp_reader_query_set_reset_symbol_dict(query, reset_symbol_dict)

  qwp_reader_query_set_reset_symbol_dict(__pyx_v_query, __pyx_v_reset_symbol_dict);

 0533: 

+0534:     qwp_reader_query_on_failover_reset(

  qwp_reader_query_on_failover_reset(__pyx_v_query, __pyx_f_7questdb_7_client__failover_reset_trampoline, ((void *)(&__pyx_v_handle->_reset_seq)));

 0535:         query, _failover_reset_trampoline, <void*>&handle._reset_seq)

 0536: 

 0537:     # Mark the reader unrecyclable only once we cross the network boundary:

 0538:     # a client-side failure above (bad SQL/bind) leaves the reader clean, so

 0539:     # a pooled lease must not drop a healthy connection over it.

+0540:     reader_handle._must_close = True

  __pyx_v_reader_handle->_must_close = 1;

 0541: 

+0542:     with nogil:

  {
      PyThreadState * _save;
      _save = PyEval_SaveThread();
      __Pyx_FastGIL_Remember();
      /*try:*/ {
/* … */
      /*finally:*/ {
        /*normal exit:*/{
          __Pyx_FastGIL_Forget();
          PyEval_RestoreThread(_save);
          goto __pyx_L20;
        }
        __pyx_L20:;
      }
  }

+0543:         cursor = qwp_reader_query_execute(&query, &err)

        __pyx_v_cursor = qwp_reader_query_execute((&__pyx_v_query), (&__pyx_v_err));
      }

 0544: 

+0545:     if cursor == NULL:

  __pyx_t_4 = (__pyx_v_cursor == NULL);
  if (__pyx_t_4) {
/* … */
  }

 0546:         # _query_execute consumes the query (nulls *query_inout); the

 0547:         # defensive free is a no-op on the consumed handle.

+0548:         qwp_reader_query_free(query)

    qwp_reader_query_free(__pyx_v_query);

+0549:         if err == NULL:

    __pyx_t_4 = (__pyx_v_err == NULL);
    if (unlikely(__pyx_t_4)) {
/* … */
    }

+0550:             raise QuestDBError(

      __pyx_t_7 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 550, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);

+0551:                 QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 551, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 551, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_1))) {
        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
        assert(__pyx_t_7);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_7);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_1, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_8, __pyx_mstate_global->__pyx_kp_u_qwp_reader_query_execute_returne};
        __pyx_t_9 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 550, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
      }
      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __PYX_ERR(2, 550, __pyx_L1_error)

 0552:                 'qwp_reader_query_execute returned NULL without setting err')

+0553:         raise _reader_err_to_py(err)

    __pyx_t_9 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 553, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_Raise(__pyx_t_9, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __PYX_ERR(2, 553, __pyx_L1_error)

 0554: 

+0555:     handle._attach(cursor, reader_handle)

  __pyx_t_9 = ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_handle->__pyx_vtab)->_attach(__pyx_v_handle, __pyx_v_cursor, __pyx_v_reader_handle); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 555, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+0556:     return handle

  __Pyx_XDECREF((PyObject *)__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_handle);
  __pyx_r = __pyx_v_handle;
  goto __pyx_L0;

 0557: 

 0558: 

+0559: cdef enum:

enum  {

+0560:     _ARROW_METADATA_CLONE_CAP = 1 << 20

  __pyx_e_7questdb_7_client__ARROW_METADATA_CLONE_CAP = (1 << 20)
};

 0561: 

 0562: 

+0563: cdef size_t _arrow_metadata_byte_len(

static size_t __pyx_f_7questdb_7_client__arrow_metadata_byte_len(char const *__pyx_v_md, size_t __pyx_v_max_len, int32_t *__pyx_v_kept_n) {
  int32_t __pyx_v_n;
  int32_t __pyx_v_klen;
  int32_t __pyx_v_vlen;
  size_t __pyx_v_pos;
  int32_t __pyx_v_i;
  size_t __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 0564:         const char* md, size_t max_len, int32_t* kept_n) noexcept:

 0565:     cdef int32_t n

 0566:     cdef int32_t klen

 0567:     cdef int32_t vlen

 0568:     cdef size_t pos

 0569:     cdef int32_t i

+0570:     kept_n[0] = 0

  (__pyx_v_kept_n[0]) = 0;

+0571:     if max_len < sizeof(int32_t):

  __pyx_t_1 = (__pyx_v_max_len < (sizeof(int32_t)));
  if (__pyx_t_1) {
/* … */
  }

+0572:         return 0

    __pyx_r = 0;
    goto __pyx_L0;

+0573:     memcpy(&n, md, sizeof(int32_t))

  (void)(memcpy((&__pyx_v_n), __pyx_v_md, (sizeof(int32_t))));

+0574:     pos = sizeof(int32_t)

  __pyx_v_pos = (sizeof(int32_t));

+0575:     if n <= 0:

  __pyx_t_1 = (__pyx_v_n <= 0);
  if (__pyx_t_1) {
/* … */
  }

+0576:         return pos

    __pyx_r = __pyx_v_pos;
    goto __pyx_L0;

+0577:     for i in range(n):

  __pyx_t_2 = __pyx_v_n;
  __pyx_t_3 = __pyx_t_2;
  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
    __pyx_v_i = __pyx_t_4;

+0578:         if max_len - pos < sizeof(int32_t):

    __pyx_t_1 = ((__pyx_v_max_len - __pyx_v_pos) < (sizeof(int32_t)));
    if (__pyx_t_1) {
/* … */
    }

+0579:             return pos

      __pyx_r = __pyx_v_pos;
      goto __pyx_L0;

+0580:         memcpy(&klen, md + pos, sizeof(int32_t))

    (void)(memcpy((&__pyx_v_klen), (__pyx_v_md + __pyx_v_pos), (sizeof(int32_t))));

+0581:         if klen < 0 or <size_t>klen > max_len - pos - sizeof(int32_t):

    __pyx_t_5 = (__pyx_v_klen < 0);
    if (!__pyx_t_5) {
    } else {
      __pyx_t_1 = __pyx_t_5;
      goto __pyx_L9_bool_binop_done;
    }
    __pyx_t_5 = (((size_t)__pyx_v_klen) > ((__pyx_v_max_len - __pyx_v_pos) - (sizeof(int32_t))));
    __pyx_t_1 = __pyx_t_5;
    __pyx_L9_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+0582:             return pos

      __pyx_r = __pyx_v_pos;
      goto __pyx_L0;

+0583:         pos += sizeof(int32_t) + <size_t>klen

    __pyx_v_pos = (__pyx_v_pos + ((sizeof(int32_t)) + ((size_t)__pyx_v_klen)));

+0584:         if max_len - pos < sizeof(int32_t):

    __pyx_t_1 = ((__pyx_v_max_len - __pyx_v_pos) < (sizeof(int32_t)));
    if (__pyx_t_1) {
/* … */
    }

+0585:             return pos

      __pyx_r = __pyx_v_pos;
      goto __pyx_L0;

+0586:         memcpy(&vlen, md + pos, sizeof(int32_t))

    (void)(memcpy((&__pyx_v_vlen), (__pyx_v_md + __pyx_v_pos), (sizeof(int32_t))));

+0587:         if vlen < 0 or <size_t>vlen > max_len - pos - sizeof(int32_t):

    __pyx_t_5 = (__pyx_v_vlen < 0);
    if (!__pyx_t_5) {
    } else {
      __pyx_t_1 = __pyx_t_5;
      goto __pyx_L13_bool_binop_done;
    }
    __pyx_t_5 = (((size_t)__pyx_v_vlen) > ((__pyx_v_max_len - __pyx_v_pos) - (sizeof(int32_t))));
    __pyx_t_1 = __pyx_t_5;
    __pyx_L13_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+0588:             return pos

      __pyx_r = __pyx_v_pos;
      goto __pyx_L0;

+0589:         pos += sizeof(int32_t) + <size_t>vlen

    __pyx_v_pos = (__pyx_v_pos + ((sizeof(int32_t)) + ((size_t)__pyx_v_vlen)));

+0590:         kept_n[0] = i + 1

    (__pyx_v_kept_n[0]) = (__pyx_v_i + 1);
  }

+0591:     return pos

  __pyx_r = __pyx_v_pos;
  goto __pyx_L0;

 0592: 

 0593: 

+0594: cdef void _arrow_schema_clone_release(ArrowSchema* schema) noexcept:

static void __pyx_f_7questdb_7_client__arrow_schema_clone_release(struct ArrowSchema *__pyx_v_schema) {
  int64_t __pyx_v_i;
/* … */
  /* function exit code */
}

 0595:     cdef int64_t i

+0596:     if schema.format != NULL:

  __pyx_t_1 = (__pyx_v_schema->format != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0597:         free(<void*>schema.format)

    free(((void *)__pyx_v_schema->format));

+0598:         schema.format = NULL

    __pyx_v_schema->format = NULL;

+0599:     if schema.name != NULL:

  __pyx_t_1 = (__pyx_v_schema->name != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0600:         free(<void*>schema.name)

    free(((void *)__pyx_v_schema->name));

+0601:         schema.name = NULL

    __pyx_v_schema->name = NULL;

+0602:     if schema.metadata != NULL:

  __pyx_t_1 = (__pyx_v_schema->metadata != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0603:         free(<void*>schema.metadata)

    free(((void *)__pyx_v_schema->metadata));

+0604:         schema.metadata = NULL

    __pyx_v_schema->metadata = NULL;

+0605:     if schema.children != NULL:

  __pyx_t_1 = (__pyx_v_schema->children != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0606:         for i in range(schema.n_children):

    __pyx_t_2 = __pyx_v_schema->n_children;
    __pyx_t_3 = __pyx_t_2;
    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
      __pyx_v_i = __pyx_t_4;

+0607:             if schema.children[i] != NULL:

      __pyx_t_1 = ((__pyx_v_schema->children[__pyx_v_i]) != NULL);
      if (__pyx_t_1) {
/* … */
      }
    }

+0608:                 if schema.children[i].release != NULL:

        __pyx_t_1 = ((__pyx_v_schema->children[__pyx_v_i])->release != NULL);
        if (__pyx_t_1) {
/* … */
        }

+0609:                     schema.children[i].release(schema.children[i])

          (__pyx_v_schema->children[__pyx_v_i])->release((__pyx_v_schema->children[__pyx_v_i]));

+0610:                 free(schema.children[i])

        free((__pyx_v_schema->children[__pyx_v_i]));

+0611:         free(schema.children)

    free(__pyx_v_schema->children);

+0612:         schema.children = NULL

    __pyx_v_schema->children = NULL;

+0613:     if schema.dictionary != NULL:

  __pyx_t_1 = (__pyx_v_schema->dictionary != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0614:         if schema.dictionary.release != NULL:

    __pyx_t_1 = (__pyx_v_schema->dictionary->release != NULL);
    if (__pyx_t_1) {
/* … */
    }

+0615:             schema.dictionary.release(schema.dictionary)

      __pyx_v_schema->dictionary->release(__pyx_v_schema->dictionary);

+0616:         free(schema.dictionary)

    free(__pyx_v_schema->dictionary);

+0617:         schema.dictionary = NULL

    __pyx_v_schema->dictionary = NULL;

+0618:     schema.release = NULL

  __pyx_v_schema->release = NULL;

 0619: 

 0620: 

+0621: cdef int _arrow_schema_deep_clone(const ArrowSchema* src, ArrowSchema* dst) noexcept:

static int __pyx_f_7questdb_7_client__arrow_schema_deep_clone(struct ArrowSchema const *__pyx_v_src, struct ArrowSchema *__pyx_v_dst) {
  size_t __pyx_v_format_len;
  size_t __pyx_v_name_len;
  size_t __pyx_v_metadata_len;
  int32_t __pyx_v_kept_n;
  int64_t __pyx_v_i;
  struct ArrowSchema *__pyx_v_child;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 0622:     cdef size_t format_len

 0623:     cdef size_t name_len

 0624:     cdef size_t metadata_len

 0625:     cdef int32_t kept_n

 0626:     cdef int64_t i

 0627:     cdef ArrowSchema* child

+0628:     memset(dst, 0, sizeof(ArrowSchema))

  (void)(memset(__pyx_v_dst, 0, (sizeof(struct ArrowSchema))));

+0629:     dst.flags = src.flags

  __pyx_t_1 = __pyx_v_src->flags;
  __pyx_v_dst->flags = __pyx_t_1;

+0630:     dst.n_children = src.n_children

  __pyx_t_1 = __pyx_v_src->n_children;
  __pyx_v_dst->n_children = __pyx_t_1;

+0631:     if src.format != NULL:

  __pyx_t_2 = (__pyx_v_src->format != NULL);
  if (__pyx_t_2) {
/* … */
  }

+0632:         format_len = strlen(src.format)

    __pyx_v_format_len = strlen(__pyx_v_src->format);

+0633:         dst.format = <const char*>malloc(format_len + 1)

    __pyx_v_dst->format = ((char const *)malloc((__pyx_v_format_len + 1)));

+0634:         if dst.format == NULL:

    __pyx_t_2 = (__pyx_v_dst->format == NULL);
    if (__pyx_t_2) {
/* … */
    }

+0635:             _arrow_schema_clone_release(dst)

      __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0636:             return -1

      __pyx_r = -1;
      goto __pyx_L0;

+0637:         memcpy(<void*>dst.format, src.format, format_len + 1)

    (void)(memcpy(((void *)__pyx_v_dst->format), __pyx_v_src->format, (__pyx_v_format_len + 1)));

+0638:     if src.name != NULL:

  __pyx_t_2 = (__pyx_v_src->name != NULL);
  if (__pyx_t_2) {
/* … */
  }

+0639:         name_len = strlen(src.name)

    __pyx_v_name_len = strlen(__pyx_v_src->name);

+0640:         dst.name = <const char*>malloc(name_len + 1)

    __pyx_v_dst->name = ((char const *)malloc((__pyx_v_name_len + 1)));

+0641:         if dst.name == NULL:

    __pyx_t_2 = (__pyx_v_dst->name == NULL);
    if (__pyx_t_2) {
/* … */
    }

+0642:             _arrow_schema_clone_release(dst)

      __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0643:             return -1

      __pyx_r = -1;
      goto __pyx_L0;

+0644:         memcpy(<void*>dst.name, src.name, name_len + 1)

    (void)(memcpy(((void *)__pyx_v_dst->name), __pyx_v_src->name, (__pyx_v_name_len + 1)));

+0645:     if src.metadata != NULL:

  __pyx_t_2 = (__pyx_v_src->metadata != NULL);
  if (__pyx_t_2) {
/* … */
  }

+0646:         metadata_len = _arrow_metadata_byte_len(

    __pyx_v_metadata_len = __pyx_f_7questdb_7_client__arrow_metadata_byte_len(__pyx_v_src->metadata, __pyx_e_7questdb_7_client__ARROW_METADATA_CLONE_CAP, (&__pyx_v_kept_n));

 0647:             src.metadata, _ARROW_METADATA_CLONE_CAP, &kept_n)

+0648:         dst.metadata = <const char*>malloc(metadata_len)

    __pyx_v_dst->metadata = ((char const *)malloc(__pyx_v_metadata_len));

+0649:         if dst.metadata == NULL:

    __pyx_t_2 = (__pyx_v_dst->metadata == NULL);
    if (__pyx_t_2) {
/* … */
    }

+0650:             _arrow_schema_clone_release(dst)

      __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0651:             return -1

      __pyx_r = -1;
      goto __pyx_L0;

+0652:         memcpy(<void*>dst.metadata, src.metadata, metadata_len)

    (void)(memcpy(((void *)__pyx_v_dst->metadata), __pyx_v_src->metadata, __pyx_v_metadata_len));

 0653:         # Keep the cloned block self-consistent: its leading key/value count

 0654:         # must never exceed the entries actually copied, or a downstream

 0655:         # consumer would read past the allocation.

+0656:         memcpy(<void*>dst.metadata, &kept_n, sizeof(int32_t))

    (void)(memcpy(((void *)__pyx_v_dst->metadata), (&__pyx_v_kept_n), (sizeof(int32_t))));

+0657:     if src.n_children > 0:

  __pyx_t_2 = (__pyx_v_src->n_children > 0);
  if (__pyx_t_2) {
/* … */
  }

+0658:         dst.children = <ArrowSchema**>calloc(

    __pyx_v_dst->children = ((struct ArrowSchema **)calloc(((size_t)__pyx_v_src->n_children), (sizeof(struct ArrowSchema *))));

 0659:             <size_t>src.n_children, sizeof(ArrowSchema*))

+0660:         if dst.children == NULL:

    __pyx_t_2 = (__pyx_v_dst->children == NULL);
    if (__pyx_t_2) {
/* … */
    }

+0661:             _arrow_schema_clone_release(dst)

      __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0662:             return -1

      __pyx_r = -1;
      goto __pyx_L0;

+0663:         for i in range(src.n_children):

    __pyx_t_1 = __pyx_v_src->n_children;
    __pyx_t_3 = __pyx_t_1;
    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
      __pyx_v_i = __pyx_t_4;

+0664:             child = <ArrowSchema*>malloc(sizeof(ArrowSchema))

      __pyx_v_child = ((struct ArrowSchema *)malloc((sizeof(struct ArrowSchema))));

+0665:             if child == NULL:

      __pyx_t_2 = (__pyx_v_child == NULL);
      if (__pyx_t_2) {
/* … */
      }

+0666:                 _arrow_schema_clone_release(dst)

        __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0667:                 return -1

        __pyx_r = -1;
        goto __pyx_L0;

+0668:             dst.children[i] = child

      (__pyx_v_dst->children[__pyx_v_i]) = __pyx_v_child;

+0669:             if _arrow_schema_deep_clone(src.children[i], child) != 0:

      __pyx_t_2 = (__pyx_f_7questdb_7_client__arrow_schema_deep_clone((__pyx_v_src->children[__pyx_v_i]), __pyx_v_child) != 0);
      if (__pyx_t_2) {
/* … */
      }
    }

+0670:                 _arrow_schema_clone_release(dst)

        __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0671:                 return -1

        __pyx_r = -1;
        goto __pyx_L0;

+0672:     if src.dictionary != NULL:

  __pyx_t_2 = (__pyx_v_src->dictionary != NULL);
  if (__pyx_t_2) {
/* … */
  }

+0673:         dst.dictionary = <ArrowSchema*>malloc(sizeof(ArrowSchema))

    __pyx_v_dst->dictionary = ((struct ArrowSchema *)malloc((sizeof(struct ArrowSchema))));

+0674:         if dst.dictionary == NULL:

    __pyx_t_2 = (__pyx_v_dst->dictionary == NULL);
    if (__pyx_t_2) {
/* … */
    }

+0675:             _arrow_schema_clone_release(dst)

      __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0676:             return -1

      __pyx_r = -1;
      goto __pyx_L0;

+0677:         if _arrow_schema_deep_clone(src.dictionary, dst.dictionary) != 0:

    __pyx_t_2 = (__pyx_f_7questdb_7_client__arrow_schema_deep_clone(__pyx_v_src->dictionary, __pyx_v_dst->dictionary) != 0);
    if (__pyx_t_2) {
/* … */
    }

+0678:             _arrow_schema_clone_release(dst)

      __pyx_f_7questdb_7_client__arrow_schema_clone_release(__pyx_v_dst);

+0679:             return -1

      __pyx_r = -1;
      goto __pyx_L0;

+0680:     dst.release = _arrow_schema_clone_release

  __pyx_v_dst->release = __pyx_f_7questdb_7_client__arrow_schema_clone_release;

+0681:     return 0

  __pyx_r = 0;
  goto __pyx_L0;

 0682: 

 0683: 

+0684: cdef class _QueryStreamProducer:

struct __pyx_obj_7questdb_7_client__QueryStreamProducer {
  PyObject_HEAD
  struct __pyx_vtabstruct_7questdb_7_client__QueryStreamProducer *__pyx_vtab;
  struct __pyx_obj_7questdb_7_client__CursorHandle *cursor_handle;
  struct ArrowSchema cached_schema;
  struct ArrowArray cached_array;
  int has_cached_schema;
  int has_cached_array;
  int exhausted;
  int delivered;
  char *last_error;
  int seen_seq;
};
/* … */
struct __pyx_vtabstruct_7questdb_7_client__QueryStreamProducer {
  void (*_free_cached)(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *);
};
static struct __pyx_vtabstruct_7questdb_7_client__QueryStreamProducer *__pyx_vtabptr_7questdb_7_client__QueryStreamProducer;

 0685:     """Holder for the Rust-cursor-backed ArrowArrayStream.

 0686: 

 0687:     The Arrow stream struct itself is owned by the enclosing PyCapsule;

 0688:     this object owns just the cached `(schema, array)` and the

 0689:     `_CursorHandle` keep-alive. Refcount is bumped on capsule creation

 0690:     and dropped by the stream's release callback so the consumer's

 0691:     capsule lifetime governs everything downstream.

 0692:     """

 0693:     cdef _CursorHandle cursor_handle

 0694:     cdef ArrowSchema cached_schema

 0695:     cdef ArrowArray cached_array

 0696:     cdef bint has_cached_schema

 0697:     cdef bint has_cached_array

 0698:     cdef bint exhausted

 0699:     cdef bint delivered

 0700:     cdef char* last_error

 0701:     cdef int seen_seq

 0702: 

+0703:     def __cinit__(self):

/* Python wrapper */
static int __pyx_pw_7questdb_7_client_20_QueryStreamProducer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_7questdb_7_client_20_QueryStreamProducer_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1; }
  const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
  if (unlikely(__pyx_kwds_len < 0)) return -1;
  if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__cinit__", __pyx_kwds); return -1;}
  __pyx_r = __pyx_pf_7questdb_7_client_20_QueryStreamProducer___cinit__(((struct __pyx_obj_7questdb_7_client__QueryStreamProducer *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_7questdb_7_client_20_QueryStreamProducer___cinit__(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_self) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0704:         self.cursor_handle = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->cursor_handle);
  __Pyx_DECREF((PyObject *)__pyx_v_self->cursor_handle);
  __pyx_v_self->cursor_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)Py_None);

+0705:         self.has_cached_schema = False

  __pyx_v_self->has_cached_schema = 0;

+0706:         self.has_cached_array = False

  __pyx_v_self->has_cached_array = 0;

+0707:         self.exhausted = False

  __pyx_v_self->exhausted = 0;

+0708:         self.delivered = False

  __pyx_v_self->delivered = 0;

+0709:         self.last_error = NULL

  __pyx_v_self->last_error = NULL;

+0710:         self.seen_seq = 0

  __pyx_v_self->seen_seq = 0;

+0711:         memset(&self.cached_schema, 0, sizeof(ArrowSchema))

  (void)(memset((&__pyx_v_self->cached_schema), 0, (sizeof(struct ArrowSchema))));

+0712:         memset(&self.cached_array, 0, sizeof(ArrowArray))

  (void)(memset((&__pyx_v_self->cached_array), 0, (sizeof(struct ArrowArray))));

 0713: 

+0714:     cdef void _free_cached(self) noexcept:

static void __pyx_f_7questdb_7_client_20_QueryStreamProducer__free_cached(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_self) {
/* … */
  /* function exit code */
}

+0715:         if self.has_cached_schema:

  if (__pyx_v_self->has_cached_schema) {
/* … */
  }

+0716:             if self.cached_schema.release != NULL:

    __pyx_t_1 = (__pyx_v_self->cached_schema.release != NULL);
    if (__pyx_t_1) {
/* … */
    }

+0717:                 self.cached_schema.release(&self.cached_schema)

      __pyx_v_self->cached_schema.release((&__pyx_v_self->cached_schema));

+0718:             self.has_cached_schema = False

    __pyx_v_self->has_cached_schema = 0;

+0719:         if self.has_cached_array:

  if (__pyx_v_self->has_cached_array) {
/* … */
  }

+0720:             if self.cached_array.release != NULL:

    __pyx_t_1 = (__pyx_v_self->cached_array.release != NULL);
    if (__pyx_t_1) {
/* … */
    }

+0721:                 self.cached_array.release(&self.cached_array)

      __pyx_v_self->cached_array.release((&__pyx_v_self->cached_array));

+0722:             self.has_cached_array = False

    __pyx_v_self->has_cached_array = 0;

 0723: 

+0724:     def __dealloc__(self):

/* Python wrapper */
static void __pyx_pw_7questdb_7_client_20_QueryStreamProducer_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_7questdb_7_client_20_QueryStreamProducer_3__dealloc__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_pf_7questdb_7_client_20_QueryStreamProducer_2__dealloc__(((struct __pyx_obj_7questdb_7_client__QueryStreamProducer *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_7questdb_7_client_20_QueryStreamProducer_2__dealloc__(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_self) {
/* … */
  /* function exit code */
}

+0725:         self._free_cached()

  ((struct __pyx_vtabstruct_7questdb_7_client__QueryStreamProducer *)__pyx_v_self->__pyx_vtab)->_free_cached(__pyx_v_self);

+0726:         if self.last_error != NULL:

  __pyx_t_1 = (__pyx_v_self->last_error != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0727:             free(self.last_error)

    free(__pyx_v_self->last_error);

+0728:             self.last_error = NULL

    __pyx_v_self->last_error = NULL;

 0729: 

 0730: 

+0731: cdef void _qs_set_error(_QueryStreamProducer prod, const char* msg, size_t msg_len) noexcept:

static void __pyx_f_7questdb_7_client__qs_set_error(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod, char const *__pyx_v_msg, size_t __pyx_v_msg_len) {
/* … */
  /* function exit code */
  __pyx_L0:;
}

+0732:     if prod.last_error != NULL:

  __pyx_t_1 = (__pyx_v_prod->last_error != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0733:         free(prod.last_error)

    free(__pyx_v_prod->last_error);

+0734:         prod.last_error = NULL

    __pyx_v_prod->last_error = NULL;

+0735:     prod.last_error = <char*>malloc(msg_len + 1)

  __pyx_v_prod->last_error = ((char *)malloc((__pyx_v_msg_len + 1)));

+0736:     if prod.last_error == NULL:

  __pyx_t_1 = (__pyx_v_prod->last_error == NULL);
  if (__pyx_t_1) {
/* … */
  }

+0737:         return

    goto __pyx_L0;

+0738:     memcpy(prod.last_error, msg, msg_len)

  (void)(memcpy(__pyx_v_prod->last_error, __pyx_v_msg, __pyx_v_msg_len));

+0739:     prod.last_error[msg_len] = 0

  (__pyx_v_prod->last_error[__pyx_v_msg_len]) = 0;

 0740: 

 0741: 

+0742: cdef int _qs_pull(_QueryStreamProducer prod) noexcept with gil:

static int __pyx_f_7questdb_7_client__qs_pull(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod) {
  PyObject *__pyx_v_full = 0;
  PyObject *__pyx_v_e = NULL;
  int __pyx_r;
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_INCREF((PyObject *)__pyx_v_prod);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_WriteUnraisable("questdb._client._qs_pull", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_full);
  __Pyx_XDECREF(__pyx_v_e);
  __Pyx_XDECREF((PyObject *)__pyx_v_prod);
  __Pyx_RefNannyFinishContext();
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  return __pyx_r;
}

 0743:     cdef bytes full

+0744:     try:

  {
    /*try:*/ {
/* … */
    }
    __pyx_L3_error:;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L7_try_return:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L0;
    __pyx_L6_except_return:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L0;
  }

+0745:         return _qs_pull_impl(prod)

      __pyx_t_4 = __pyx_f_7questdb_7_client__qs_pull_impl(__pyx_v_prod); if (unlikely(__pyx_t_4 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 745, __pyx_L3_error)
      __pyx_r = __pyx_t_4;
      goto __pyx_L7_try_return;

+0746:     except BaseException as e:

    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_BaseException))));
    if (__pyx_t_4) {
      __Pyx_AddTraceback("questdb._client._qs_pull", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 746, __pyx_L5_except_error)
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_6);
      __pyx_v_e = __pyx_t_6;
      /*try:*/ {
/* … */
      /*finally:*/ {
        __pyx_L14_error:;
        /*exception exit:*/{
          __Pyx_PyThreadState_declare
          __Pyx_PyThreadState_assign
          __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
           __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
          if ( unlikely(__Pyx_GetException(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8);
          __Pyx_XGOTREF(__pyx_t_10);
          __Pyx_XGOTREF(__pyx_t_9);
          __Pyx_XGOTREF(__pyx_t_8);
          __Pyx_XGOTREF(__pyx_t_18);
          __Pyx_XGOTREF(__pyx_t_19);
          __Pyx_XGOTREF(__pyx_t_20);
          __pyx_t_4 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename;
          {
            __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
          }
          __Pyx_XGIVEREF(__pyx_t_18);
          __Pyx_XGIVEREF(__pyx_t_19);
          __Pyx_XGIVEREF(__pyx_t_20);
          __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
          __Pyx_XGIVEREF(__pyx_t_10);
          __Pyx_XGIVEREF(__pyx_t_9);
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_ErrRestore(__pyx_t_10, __pyx_t_9, __pyx_t_8);
          __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
          __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17;
          goto __pyx_L5_except_error;
        }
        __pyx_L13_return: {
          __pyx_t_16 = __pyx_r;
          __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
          __pyx_r = __pyx_t_16;
          goto __pyx_L6_except_return;
        }
      }
    }
    goto __pyx_L5_except_error;

+0747:         try:

        {
          /*try:*/ {
/* … */
          }
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          goto __pyx_L23_try_end;
          __pyx_L16_error:;
          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
/* … */
          __pyx_L18_except_error:;
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_XGIVEREF(__pyx_t_9);
          __Pyx_XGIVEREF(__pyx_t_10);
          __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
          goto __pyx_L14_error;
          __pyx_L17_exception_handled:;
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_XGIVEREF(__pyx_t_9);
          __Pyx_XGIVEREF(__pyx_t_10);
          __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
          __pyx_L23_try_end:;
        }

+0748:             full = ('arrow batch pull failed: ' + repr(e)).encode('utf-8')

            __pyx_t_11 = PyObject_Repr(__pyx_v_e); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 748, __pyx_L16_error)
            __Pyx_GOTREF(__pyx_t_11);
            __pyx_t_12 = __Pyx_PyUnicode_ConcatSafe(__pyx_mstate_global->__pyx_kp_u_arrow_batch_pull_failed, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 748, __pyx_L16_error)
            __Pyx_GOTREF(__pyx_t_12);
            __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
            __pyx_t_11 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_12)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 748, __pyx_L16_error)
            __Pyx_GOTREF(__pyx_t_11);
            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
            __pyx_v_full = ((PyObject*)__pyx_t_11);
            __pyx_t_11 = 0;

+0749:             _qs_set_error(prod, full, <size_t>len(full))

            __pyx_t_13 = __Pyx_PyBytes_AsString(__pyx_v_full); if (unlikely((!__pyx_t_13) && PyErr_Occurred())) __PYX_ERR(2, 749, __pyx_L16_error)
            __pyx_t_14 = __Pyx_PyBytes_GET_SIZE(__pyx_v_full); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(2, 749, __pyx_L16_error)
            __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_t_13, ((size_t)__pyx_t_14));

+0750:         except:

          /*except:*/ {
            __Pyx_AddTraceback("questdb._client._qs_pull", __pyx_clineno, __pyx_lineno, __pyx_filename);
            if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_15) < 0) __PYX_ERR(2, 750, __pyx_L18_except_error)
            __Pyx_XGOTREF(__pyx_t_11);
            __Pyx_XGOTREF(__pyx_t_12);
            __Pyx_XGOTREF(__pyx_t_15);

+0751:             _qs_set_error(prod, b'arrow batch pull failed', 23)

            __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_k_arrow_batch_pull_failed_2, 23);
            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
            goto __pyx_L17_exception_handled;
          }

+0752:         prod.exhausted = True

        __pyx_v_prod->exhausted = 1;

+0753:         return -1

        __pyx_r = -1;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        goto __pyx_L13_return;
      }

 0754: 

 0755: 

+0756: cdef int _qs_pull_impl(_QueryStreamProducer prod):

static int __pyx_f_7questdb_7_client__qs_pull_impl(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod) {
  struct qwp_reader_cursor *__pyx_v_cursor;
  struct ArrowArray __pyx_v_local_array;
  struct ArrowSchema __pyx_v_local_schema;
  questdb_error *__pyx_v_err;
  enum qwp_reader_arrow_batch_result __pyx_v_result;
  char const *__pyx_v_err_msg;
  size_t __pyx_v_err_len;
  questdb_error_code __pyx_v_code;
  PyObject *__pyx_v_py_msg = 0;
  PyObject *__pyx_v_full = 0;
  PyObject *__pyx_v_fallback = NULL;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("questdb._client._qs_pull_impl", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_py_msg);
  __Pyx_XDECREF(__pyx_v_full);
  __Pyx_XDECREF(__pyx_v_fallback);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0757:     cdef qwp_reader_cursor* cursor

 0758:     cdef ArrowArray local_array

 0759:     cdef ArrowSchema local_schema

+0760:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 0761:     cdef qwp_reader_arrow_batch_result result

+0762:     cdef const char* err_msg = NULL

  __pyx_v_err_msg = NULL;

+0763:     cdef size_t err_len = 0

  __pyx_v_err_len = 0;

 0764:     cdef questdb_error_code code

 0765:     cdef object py_msg

 0766:     cdef bytes full

+0767:     if prod.exhausted:

  if (__pyx_v_prod->exhausted) {
/* … */
  }

 0768:         # A prior error left a diagnostic pinned; keep surfacing it rather

 0769:         # than reporting a clean end-of-stream to a consumer that pulls again.

+0770:         if prod.last_error != NULL:

    __pyx_t_1 = (__pyx_v_prod->last_error != NULL);
    if (__pyx_t_1) {
/* … */
    }

+0771:             return -1

      __pyx_r = -1;
      goto __pyx_L0;

+0772:         return 0

    __pyx_r = 0;
    goto __pyx_L0;

+0773:     if prod.cursor_handle is None:

  __pyx_t_1 = (((PyObject *)__pyx_v_prod->cursor_handle) == Py_None);
  if (__pyx_t_1) {
/* … */
  }

+0774:         _qs_set_error(prod, b'cursor is closed', 16)

    __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_k_cursor_is_closed, 16);

+0775:         prod.exhausted = True

    __pyx_v_prod->exhausted = 1;

+0776:         return -1

    __pyx_r = -1;
    goto __pyx_L0;

+0777:     memset(&local_array, 0, sizeof(ArrowArray))

  (void)(memset((&__pyx_v_local_array), 0, (sizeof(struct ArrowArray))));

+0778:     memset(&local_schema, 0, sizeof(ArrowSchema))

  (void)(memset((&__pyx_v_local_schema), 0, (sizeof(struct ArrowSchema))));

+0779:     with prod.cursor_handle._lock:

  /*with:*/ {
    __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_v_prod->cursor_handle->_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 779, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = NULL;
    __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_v_prod->cursor_handle->_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 779, __pyx_L6_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 779, __pyx_L6_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    /*try:*/ {
      {
        /*try:*/ {
/* … */
        }
        goto __pyx_L15_try_end;
        __pyx_L14_try_return:;
        goto __pyx_L7_return;
        __pyx_L15_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_2) {
          __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[2], NULL);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 779, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        goto __pyx_L9;
      }
      __pyx_L7_return: {
        __pyx_t_11 = __pyx_r;
        if (__pyx_t_2) {
          __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[2], NULL);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 779, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        __pyx_r = __pyx_t_11;
        goto __pyx_L0;
      }
      __pyx_L9:;
    }
    goto __pyx_L20;
    __pyx_L6_error:;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    goto __pyx_L1_error;
    __pyx_L20:;
  }

+0780:         cursor = prod.cursor_handle._cursor

          __pyx_t_10 = __pyx_v_prod->cursor_handle->_cursor;
          __pyx_v_cursor = __pyx_t_10;

+0781:         if cursor == NULL:

          __pyx_t_1 = (__pyx_v_cursor == NULL);
          if (__pyx_t_1) {
/* … */
          }

+0782:             _qs_set_error(prod, b'cursor is closed', 16)

            __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_k_cursor_is_closed, 16);

+0783:             prod.exhausted = True

            __pyx_v_prod->exhausted = 1;

+0784:             return -1

            __pyx_r = -1;
            goto __pyx_L14_try_return;

+0785:         with nogil:

          {
              PyThreadState * _save;
              _save = PyEval_SaveThread();
              __Pyx_FastGIL_Remember();
              /*try:*/ {
/* … */
              /*finally:*/ {
                /*normal exit:*/{
                  __Pyx_FastGIL_Forget();
                  PyEval_RestoreThread(_save);
                  goto __pyx_L19;
                }
                __pyx_L19:;
              }
          }

+0786:             result = qwp_reader_cursor_next_arrow_batch_compact(

                __pyx_v_result = qwp_reader_cursor_next_arrow_batch_compact(__pyx_v_cursor, (&__pyx_v_local_array), (&__pyx_v_local_schema), (&__pyx_v_err));
              }

 0787:                 cursor, &local_array, &local_schema, &err)

+0788:     if result == qwp_reader_arrow_batch_ok:

  __pyx_t_1 = (__pyx_v_result == qwp_reader_arrow_batch_ok);
  if (__pyx_t_1) {
/* … */
  }

+0789:         if prod.cursor_handle._reset_seq != prod.seen_seq:

    __pyx_t_1 = (__pyx_v_prod->cursor_handle->_reset_seq != __pyx_v_prod->seen_seq);
    if (__pyx_t_1) {
/* … */
    }

+0790:             if prod.delivered:

      if (__pyx_v_prod->delivered) {
/* … */
      }

 0791:                 # Mid-query failover replayed from batch-0 after batches

 0792:                 # were already handed to the consumer; this one would

 0793:                 # duplicate them. Streaming can't discard it — surface a

 0794:                 # clean error (tagged like other capsule errors) and stop.

+0795:                 if local_array.release != NULL:

        __pyx_t_1 = (__pyx_v_local_array.release != NULL);
        if (__pyx_t_1) {
/* … */
        }

+0796:                     local_array.release(&local_array)

          __pyx_v_local_array.release((&__pyx_v_local_array));

+0797:                 if local_schema.release != NULL:

        __pyx_t_1 = (__pyx_v_local_schema.release != NULL);
        if (__pyx_t_1) {
/* … */
        }

+0798:                     local_schema.release(&local_schema)

          __pyx_v_local_schema.release((&__pyx_v_local_schema));

+0799:                 try:

        {
          /*try:*/ {
/* … */
          }
          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          goto __pyx_L31_try_end;
          __pyx_L26_error:;
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
          __pyx_L28_except_error:;
          __Pyx_XGIVEREF(__pyx_t_2);
          __Pyx_XGIVEREF(__pyx_t_9);
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_9, __pyx_t_8);
          goto __pyx_L1_error;
          __pyx_L27_exception_handled:;
          __Pyx_XGIVEREF(__pyx_t_2);
          __Pyx_XGIVEREF(__pyx_t_9);
          __Pyx_XGIVEREF(__pyx_t_8);
          __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_9, __pyx_t_8);
          __pyx_L31_try_end:;
        }

 0800:                     full = (

+0801:                         '[' + QuestDBErrorCode.FailoverWouldDuplicate.name + '] '

            __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 801, __pyx_L26_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_FailoverWouldDuplicate); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 801, __pyx_L26_error)
            __Pyx_GOTREF(__pyx_t_12);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 801, __pyx_L26_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
            __pyx_t_12 = PyNumber_Add(__pyx_mstate_global->__pyx_kp_u__18, __pyx_t_4); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 801, __pyx_L26_error)
            __Pyx_GOTREF(__pyx_t_12);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_4 = PyNumber_Add(__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_mid_query_failover_would_duplic); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 801, __pyx_L26_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
            __pyx_t_5 = __pyx_t_4;
            __Pyx_INCREF(__pyx_t_5);
            __pyx_t_6 = 0;
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_utf_8};
              __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 803, __pyx_L26_error)
              __Pyx_GOTREF(__pyx_t_3);
            }

 0802:                         'mid-query failover would duplicate already-delivered '

+0803:                         'batches; re-issue the query').encode('utf-8')

            if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(2, 803, __pyx_L26_error)
            __pyx_v_full = ((PyObject*)__pyx_t_3);
            __pyx_t_3 = 0;

+0804:                     _qs_set_error(prod, full, <size_t>len(full))

            if (unlikely(__pyx_v_full == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
              __PYX_ERR(2, 804, __pyx_L26_error)
            }
            __pyx_t_13 = __Pyx_PyBytes_AsString(__pyx_v_full); if (unlikely((!__pyx_t_13) && PyErr_Occurred())) __PYX_ERR(2, 804, __pyx_L26_error)
            if (unlikely(__pyx_v_full == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
              __PYX_ERR(2, 804, __pyx_L26_error)
            }
            __pyx_t_14 = __Pyx_PyBytes_GET_SIZE(__pyx_v_full); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(2, 804, __pyx_L26_error)
            __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_t_13, ((size_t)__pyx_t_14));

+0805:                 except:

          /*except:*/ {
            __Pyx_AddTraceback("questdb._client._qs_pull_impl", __pyx_clineno, __pyx_lineno, __pyx_filename);
            if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(2, 805, __pyx_L28_except_error)
            __Pyx_XGOTREF(__pyx_t_3);
            __Pyx_XGOTREF(__pyx_t_4);
            __Pyx_XGOTREF(__pyx_t_5);

 0806:                     fallback = (

+0807:                         b'[FailoverWouldDuplicate] mid-query failover would '

            __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_b_FailoverWouldDuplicate_mid_quer);
            __pyx_v_fallback = __pyx_mstate_global->__pyx_kp_b_FailoverWouldDuplicate_mid_quer;

 0808:                         b'duplicate already-delivered batches; re-issue the query')

+0809:                     _qs_set_error(prod, fallback, <size_t>len(fallback))

            __pyx_t_13 = __Pyx_PyBytes_AsString(__pyx_v_fallback); if (unlikely((!__pyx_t_13) && PyErr_Occurred())) __PYX_ERR(2, 809, __pyx_L28_except_error)
            __pyx_t_14 = __Pyx_PyBytes_GET_SIZE(__pyx_v_fallback); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(2, 809, __pyx_L28_except_error)
            __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_t_13, ((size_t)__pyx_t_14));
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
            goto __pyx_L27_exception_handled;
          }

+0810:                 prod.exhausted = True

        __pyx_v_prod->exhausted = 1;

+0811:                 return -1

        __pyx_r = -1;
        goto __pyx_L0;

 0812:             # Pre-delivery failover: nothing reached the consumer yet, so

 0813:             # re-pin to the replayed stream and restart from this batch-0.

+0814:             prod.seen_seq = prod.cursor_handle._reset_seq

      __pyx_t_11 = __pyx_v_prod->cursor_handle->_reset_seq;
      __pyx_v_prod->seen_seq = __pyx_t_11;

+0815:             prod._free_cached()

      ((struct __pyx_vtabstruct_7questdb_7_client__QueryStreamProducer *)__pyx_v_prod->__pyx_vtab)->_free_cached(__pyx_v_prod);

+0816:         if not prod.has_cached_schema:

    __pyx_t_1 = (!__pyx_v_prod->has_cached_schema);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L34;
    }

+0817:             memcpy(&prod.cached_schema, &local_schema, sizeof(ArrowSchema))

      (void)(memcpy((&__pyx_v_prod->cached_schema), (&__pyx_v_local_schema), (sizeof(struct ArrowSchema))));

+0818:             prod.has_cached_schema = True

      __pyx_v_prod->has_cached_schema = 1;

 0819:         else:

+0820:             if local_schema.release != NULL:

    /*else*/ {
      __pyx_t_1 = (__pyx_v_local_schema.release != NULL);
      if (__pyx_t_1) {
/* … */
      }
    }
    __pyx_L34:;

+0821:                 local_schema.release(&local_schema)

        __pyx_v_local_schema.release((&__pyx_v_local_schema));

+0822:         if prod.has_cached_array and prod.cached_array.release != NULL:

    if (__pyx_v_prod->has_cached_array) {
    } else {
      __pyx_t_1 = __pyx_v_prod->has_cached_array;
      goto __pyx_L37_bool_binop_done;
    }
    __pyx_t_15 = (__pyx_v_prod->cached_array.release != NULL);
    __pyx_t_1 = __pyx_t_15;
    __pyx_L37_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+0823:             prod.cached_array.release(&prod.cached_array)

      __pyx_v_prod->cached_array.release((&__pyx_v_prod->cached_array));

+0824:         memcpy(&prod.cached_array, &local_array, sizeof(ArrowArray))

    (void)(memcpy((&__pyx_v_prod->cached_array), (&__pyx_v_local_array), (sizeof(struct ArrowArray))));

+0825:         prod.has_cached_array = True

    __pyx_v_prod->has_cached_array = 1;

+0826:         return 0

    __pyx_r = 0;
    goto __pyx_L0;

+0827:     if result == qwp_reader_arrow_batch_end:

  __pyx_t_1 = (__pyx_v_result == qwp_reader_arrow_batch_end);
  if (__pyx_t_1) {
/* … */
  }

+0828:         prod.exhausted = True

    __pyx_v_prod->exhausted = 1;

+0829:         if prod.cursor_handle._reader_ref is not None:

    __pyx_t_1 = (((PyObject *)__pyx_v_prod->cursor_handle->_reader_ref) != Py_None);
    if (__pyx_t_1) {
/* … */
    }

+0830:             prod.cursor_handle._reader_ref._must_close = False

      __pyx_v_prod->cursor_handle->_reader_ref->_must_close = 0;

+0831:         return 0

    __pyx_r = 0;
    goto __pyx_L0;

+0832:     if err != NULL:

  __pyx_t_1 = (__pyx_v_err != NULL);
  if (__pyx_t_1) {
/* … */
    goto __pyx_L41;
  }

+0833:         code = questdb_error_get_code(err)

    __pyx_v_code = questdb_error_get_code(__pyx_v_err);

+0834:         err_msg = questdb_error_msg(err, &err_len)

    __pyx_v_err_msg = questdb_error_msg(__pyx_v_err, (&__pyx_v_err_len));

+0835:         try:

    {
      /*try:*/ {
/* … */
      }
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      goto __pyx_L47_try_end;
      __pyx_L42_error:;
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* … */
      __pyx_L44_except_error:;
      __Pyx_XGIVEREF(__pyx_t_8);
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_2);
      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_2);
      goto __pyx_L1_error;
      __pyx_L43_exception_handled:;
      __Pyx_XGIVEREF(__pyx_t_8);
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_2);
      __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_2);
      __pyx_L47_try_end:;
    }

+0836:             if err_msg != NULL:

        __pyx_t_1 = (__pyx_v_err_msg != NULL);
        if (__pyx_t_1) {
/* … */
          goto __pyx_L48;
        }

+0837:                 py_msg = PyUnicode_FromStringAndSize(err_msg, <Py_ssize_t>err_len)

          __pyx_t_5 = PyUnicode_FromStringAndSize(__pyx_v_err_msg, ((Py_ssize_t)__pyx_v_err_len)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 837, __pyx_L42_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_v_py_msg = __pyx_t_5;
          __pyx_t_5 = 0;

 0838:             else:

+0839:                 py_msg = 'arrow batch fetch failed'

        /*else*/ {
          __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_arrow_batch_fetch_failed);
          __pyx_v_py_msg = __pyx_mstate_global->__pyx_kp_u_arrow_batch_fetch_failed;
        }
        __pyx_L48:;

 0840:             full = (

+0841:                 '[' + _reader_err_code_to_py(code).name + '] ' + py_msg

        __pyx_t_3 = __pyx_f_7questdb_7_client__reader_err_code_to_py(__pyx_v_code); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 841, __pyx_L42_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 841, __pyx_L42_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyNumber_Add(__pyx_mstate_global->__pyx_kp_u__18, __pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 841, __pyx_L42_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_12 = PyNumber_Add(__pyx_t_3, __pyx_mstate_global->__pyx_kp_u__19); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 841, __pyx_L42_error)
        __Pyx_GOTREF(__pyx_t_12);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyNumber_Add(__pyx_t_12, __pyx_v_py_msg); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 841, __pyx_L42_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __pyx_t_4 = __pyx_t_3;
        __Pyx_INCREF(__pyx_t_4);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_utf_8};
          __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 842, __pyx_L42_error)
          __Pyx_GOTREF(__pyx_t_5);
        }

+0842:             ).encode('utf-8')

        if (!(likely(PyBytes_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_5))) __PYX_ERR(2, 842, __pyx_L42_error)
        __pyx_v_full = ((PyObject*)__pyx_t_5);
        __pyx_t_5 = 0;

+0843:             _qs_set_error(prod, full, <size_t>len(full))

        if (unlikely(__pyx_v_full == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
          __PYX_ERR(2, 843, __pyx_L42_error)
        }
        __pyx_t_13 = __Pyx_PyBytes_AsString(__pyx_v_full); if (unlikely((!__pyx_t_13) && PyErr_Occurred())) __PYX_ERR(2, 843, __pyx_L42_error)
        if (unlikely(__pyx_v_full == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
          __PYX_ERR(2, 843, __pyx_L42_error)
        }
        __pyx_t_14 = __Pyx_PyBytes_GET_SIZE(__pyx_v_full); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(2, 843, __pyx_L42_error)
        __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_t_13, ((size_t)__pyx_t_14));

+0844:         except:

      /*except:*/ {
        __Pyx_AddTraceback("questdb._client._qs_pull_impl", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(2, 844, __pyx_L44_except_error)
        __Pyx_XGOTREF(__pyx_t_5);
        __Pyx_XGOTREF(__pyx_t_3);
        __Pyx_XGOTREF(__pyx_t_4);

+0845:             if err_msg != NULL:

        __pyx_t_1 = (__pyx_v_err_msg != NULL);
        if (__pyx_t_1) {
/* … */
          goto __pyx_L51;
        }

+0846:                 _qs_set_error(prod, err_msg, err_len)

          __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_v_err_msg, __pyx_v_err_len);

 0847:             else:

+0848:                 _qs_set_error(prod, b'arrow batch fetch failed', 24)

        /*else*/ {
          __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_k_arrow_batch_fetch_failed, 24);
        }
        __pyx_L51:;
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        goto __pyx_L43_exception_handled;
      }

+0849:         questdb_error_free(err)

    questdb_error_free(__pyx_v_err);

 0850:     else:

+0851:         _qs_set_error(

  /*else*/ {
/* … */
    __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_k_arrow_batch_fetch_error_without, 39);
  }
  __pyx_L41:;

 0852:             prod,

 0853:             b'arrow batch fetch error without err_out', 39)

+0854:     prod.exhausted = True

  __pyx_v_prod->exhausted = 1;

+0855:     return -1

  __pyx_r = -1;
  goto __pyx_L0;

 0856: 

 0857: 

+0858: cdef int _qs_get_schema(ArrowArrayStream* stream, ArrowSchema* out) noexcept with gil:

static int __pyx_f_7questdb_7_client__qs_get_schema(struct ArrowArrayStream *__pyx_v_stream, struct ArrowSchema *__pyx_v_out) {
  struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod = 0;
  int __pyx_r;
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_prod);
  __Pyx_RefNannyFinishContext();
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  return __pyx_r;
}

 0859:     cdef _QueryStreamProducer prod

+0860:     if stream == NULL or stream.private_data == NULL:

  __pyx_t_2 = (__pyx_v_stream == NULL);
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_stream->private_data == NULL);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+0861:         return 22  # EINVAL

    __pyx_r = 22;
    goto __pyx_L0;

+0862:     prod = <_QueryStreamProducer>stream.private_data

  __pyx_t_3 = ((PyObject *)__pyx_v_stream->private_data);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_v_prod = ((struct __pyx_obj_7questdb_7_client__QueryStreamProducer *)__pyx_t_3);
  __pyx_t_3 = 0;

+0863:     try:

  {
    /*try:*/ {
/* … */
    }
    __pyx_L10_try_return:;
    goto __pyx_L0;
  }

+0864:         if not prod.has_cached_schema:

      __pyx_t_1 = (!__pyx_v_prod->has_cached_schema);
      if (__pyx_t_1) {
/* … */
      }

+0865:             if _qs_pull(prod) != 0:

        __pyx_t_1 = (__pyx_f_7questdb_7_client__qs_pull(__pyx_v_prod) != 0);
        if (__pyx_t_1) {
/* … */
        }

+0866:                 return 5  # EIO

          __pyx_r = 5;
          goto __pyx_L10_try_return;

+0867:         if not prod.has_cached_schema:

      __pyx_t_1 = (!__pyx_v_prod->has_cached_schema);
      if (__pyx_t_1) {
/* … */
      }

+0868:             if _qs_install_empty_struct_schema(prod) != 0:

        __pyx_t_1 = (__pyx_f_7questdb_7_client__qs_install_empty_struct_schema(__pyx_v_prod) != 0);
        if (__pyx_t_1) {
/* … */
        }

+0869:                 return 12  # ENOMEM

          __pyx_r = 12;
          goto __pyx_L10_try_return;

+0870:         if _arrow_schema_deep_clone(&prod.cached_schema, out) != 0:

      __pyx_t_1 = (__pyx_f_7questdb_7_client__arrow_schema_deep_clone((&__pyx_v_prod->cached_schema), __pyx_v_out) != 0);
      if (__pyx_t_1) {
/* … */
      }

+0871:             _qs_set_error(prod, b'failed to clone ArrowSchema', 27)

        __pyx_f_7questdb_7_client__qs_set_error(__pyx_v_prod, __pyx_k_failed_to_clone_ArrowSchema, 27);

+0872:             return 12  # ENOMEM

        __pyx_r = 12;
        goto __pyx_L10_try_return;

+0873:         return 0

      __pyx_r = 0;
      goto __pyx_L10_try_return;

 0874:     except BaseException:

 0875:         _qs_set_error(prod, b'arrow schema fetch failed', 25)

 0876:         return 5  # EIO

 0877: 

 0878: 

+0879: cdef int _qs_install_empty_struct_schema(_QueryStreamProducer prod) noexcept:

static int __pyx_f_7questdb_7_client__qs_install_empty_struct_schema(struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod) {
  char *__pyx_v_fmt;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 0880:     """For an empty result set, fabricate a zero-column struct schema

 0881:     so consumers (polars / pyarrow) iterate to a clean end-of-stream

 0882:     instead of erroring on missing schema."""

+0883:     cdef char* fmt = <char*>malloc(3)

  __pyx_v_fmt = ((char *)malloc(3));

+0884:     if fmt == NULL:

  __pyx_t_1 = (__pyx_v_fmt == NULL);
  if (__pyx_t_1) {
/* … */
  }

+0885:         return -1

    __pyx_r = -1;
    goto __pyx_L0;

+0886:     fmt[0] = b'+'

  (__pyx_v_fmt[0]) = '+';

+0887:     fmt[1] = b's'

  (__pyx_v_fmt[1]) = 's';

+0888:     fmt[2] = 0

  (__pyx_v_fmt[2]) = 0;

+0889:     memset(&prod.cached_schema, 0, sizeof(ArrowSchema))

  (void)(memset((&__pyx_v_prod->cached_schema), 0, (sizeof(struct ArrowSchema))));

+0890:     prod.cached_schema.format = fmt

  __pyx_v_prod->cached_schema.format = __pyx_v_fmt;

+0891:     prod.cached_schema.release = _arrow_schema_clone_release

  __pyx_v_prod->cached_schema.release = __pyx_f_7questdb_7_client__arrow_schema_clone_release;

+0892:     prod.has_cached_schema = True

  __pyx_v_prod->has_cached_schema = 1;

+0893:     return 0

  __pyx_r = 0;
  goto __pyx_L0;

 0894: 

 0895: 

+0896: cdef int _qs_get_next(ArrowArrayStream* stream, ArrowArray* out) noexcept with gil:

static int __pyx_f_7questdb_7_client__qs_get_next(struct ArrowArrayStream *__pyx_v_stream, struct ArrowArray *__pyx_v_out) {
  struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod = 0;
  int __pyx_r;
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_prod);
  __Pyx_RefNannyFinishContext();
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  return __pyx_r;
}

 0897:     cdef _QueryStreamProducer prod

+0898:     memset(out, 0, sizeof(ArrowArray))

  (void)(memset(__pyx_v_out, 0, (sizeof(struct ArrowArray))));

+0899:     if stream == NULL or stream.private_data == NULL:

  __pyx_t_2 = (__pyx_v_stream == NULL);
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_stream->private_data == NULL);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+0900:         return 22  # EINVAL

    __pyx_r = 22;
    goto __pyx_L0;

+0901:     prod = <_QueryStreamProducer>stream.private_data

  __pyx_t_3 = ((PyObject *)__pyx_v_stream->private_data);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_v_prod = ((struct __pyx_obj_7questdb_7_client__QueryStreamProducer *)__pyx_t_3);
  __pyx_t_3 = 0;

+0902:     try:

  {
    /*try:*/ {
/* … */
    }
    __pyx_L10_try_return:;
    goto __pyx_L0;
  }

+0903:         if not prod.has_cached_array:

      __pyx_t_1 = (!__pyx_v_prod->has_cached_array);
      if (__pyx_t_1) {
/* … */
      }

+0904:             if _qs_pull(prod) != 0:

        __pyx_t_1 = (__pyx_f_7questdb_7_client__qs_pull(__pyx_v_prod) != 0);
        if (__pyx_t_1) {
/* … */
        }

+0905:                 return 5  # EIO

          __pyx_r = 5;
          goto __pyx_L10_try_return;

+0906:         if prod.has_cached_array:

      if (__pyx_v_prod->has_cached_array) {
/* … */
      }

+0907:             memcpy(out, &prod.cached_array, sizeof(ArrowArray))

        (void)(memcpy(__pyx_v_out, (&__pyx_v_prod->cached_array), (sizeof(struct ArrowArray))));

+0908:             memset(&prod.cached_array, 0, sizeof(ArrowArray))

        (void)(memset((&__pyx_v_prod->cached_array), 0, (sizeof(struct ArrowArray))));

+0909:             prod.has_cached_array = False

        __pyx_v_prod->has_cached_array = 0;

+0910:             prod.delivered = True

        __pyx_v_prod->delivered = 1;

+0911:             return 0

        __pyx_r = 0;
        goto __pyx_L10_try_return;

+0912:         return 0

      __pyx_r = 0;
      goto __pyx_L10_try_return;

 0913:     except BaseException:

 0914:         _qs_set_error(prod, b'arrow batch fetch failed', 24)

 0915:         return 5  # EIO

 0916: 

 0917: 

+0918: cdef const char* _qs_get_last_error(ArrowArrayStream* stream) noexcept with gil:

static char const *__pyx_f_7questdb_7_client__qs_get_last_error(struct ArrowArrayStream *__pyx_v_stream) {
  struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod = 0;
  char const *__pyx_r;
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_prod);
  __Pyx_RefNannyFinishContext();
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  return __pyx_r;
}

 0919:     cdef _QueryStreamProducer prod

+0920:     if stream == NULL or stream.private_data == NULL:

  __pyx_t_2 = (__pyx_v_stream == NULL);
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_stream->private_data == NULL);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+0921:         return NULL

    __pyx_r = NULL;
    goto __pyx_L0;

+0922:     try:

  {
    /*try:*/ {
/* … */
    }
    __pyx_L10_try_return:;
    goto __pyx_L0;
  }

+0923:         prod = <_QueryStreamProducer>stream.private_data

      __pyx_t_6 = ((PyObject *)__pyx_v_stream->private_data);
      __Pyx_INCREF(__pyx_t_6);
      __pyx_v_prod = ((struct __pyx_obj_7questdb_7_client__QueryStreamProducer *)__pyx_t_6);
      __pyx_t_6 = 0;

+0924:         return <const char*>prod.last_error

      __pyx_r = ((char const *)__pyx_v_prod->last_error);
      goto __pyx_L10_try_return;

 0925:     except BaseException:

 0926:         return NULL

 0927: 

 0928: 

+0929: cdef void _qs_release(ArrowArrayStream* stream) noexcept with gil:

static void __pyx_f_7questdb_7_client__qs_release(struct ArrowArrayStream *__pyx_v_stream) {
  struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod = 0;
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_prod);
  __Pyx_RefNannyFinishContext();
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
}

 0930:     cdef _QueryStreamProducer prod

+0931:     if stream == NULL or stream.private_data == NULL:

  __pyx_t_2 = (__pyx_v_stream == NULL);
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_stream->private_data == NULL);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+0932:         return

    goto __pyx_L0;

+0933:     prod = <_QueryStreamProducer>stream.private_data

  __pyx_t_3 = ((PyObject *)__pyx_v_stream->private_data);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_v_prod = ((struct __pyx_obj_7questdb_7_client__QueryStreamProducer *)__pyx_t_3);
  __pyx_t_3 = 0;

+0934:     stream.private_data = NULL

  __pyx_v_stream->private_data = NULL;

+0935:     stream.release = NULL

  __pyx_v_stream->release = NULL;

+0936:     if prod.cursor_handle is not None:

  __pyx_t_1 = (((PyObject *)__pyx_v_prod->cursor_handle) != Py_None);
  if (__pyx_t_1) {
/* … */
  }

+0937:         prod.cursor_handle._free()

    ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_prod->cursor_handle->__pyx_vtab)->_free(__pyx_v_prod->cursor_handle);

+0938:     try:

  {
    /*try:*/ {
/* … */
    }
  }

+0939:         Py_DECREF(prod)

      Py_DECREF(((PyObject *)__pyx_v_prod));

 0940:     except BaseException:

 0941:         pass

 0942: 

 0943: 

+0944: cdef void _qs_capsule_destructor(object capsule) noexcept:

static void __pyx_f_7questdb_7_client__qs_capsule_destructor(PyObject *__pyx_v_capsule) {
  struct ArrowArrayStream *__pyx_v_stream;
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("questdb._client._qs_capsule_destructor", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
}

 0945:     cdef ArrowArrayStream* stream

+0946:     if not PyCapsule_IsValid(capsule, b'arrow_array_stream'):

  __pyx_t_1 = (!PyCapsule_IsValid(__pyx_v_capsule, __pyx_k_arrow_array_stream));
  if (__pyx_t_1) {
/* … */
  }

+0947:         return

    goto __pyx_L0;

+0948:     stream = <ArrowArrayStream*>PyCapsule_GetPointer(

  __pyx_t_2 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_k_arrow_array_stream); if (unlikely(__pyx_t_2 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 948, __pyx_L1_error)
  __pyx_v_stream = ((struct ArrowArrayStream *)__pyx_t_2);

 0949:         capsule, b'arrow_array_stream')

+0950:     if stream == NULL:

  __pyx_t_1 = (__pyx_v_stream == NULL);
  if (__pyx_t_1) {
/* … */
  }

+0951:         return

    goto __pyx_L0;

+0952:     if stream.release != NULL:

  __pyx_t_1 = (__pyx_v_stream->release != NULL);
  if (__pyx_t_1) {
/* … */
  }

+0953:         stream.release(stream)

    __pyx_v_stream->release(__pyx_v_stream);

+0954:     free(stream)

  free(__pyx_v_stream);

 0955: 

 0956: 

+0957: cdef object _make_query_stream_capsule(_CursorHandle handle):

static PyObject *__pyx_f_7questdb_7_client__make_query_stream_capsule(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle) {
  struct __pyx_obj_7questdb_7_client__QueryStreamProducer *__pyx_v_prod = 0;
  struct ArrowArrayStream *__pyx_v_stream;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("questdb._client._make_query_stream_capsule", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_prod);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0958:     cdef _QueryStreamProducer prod

 0959:     cdef ArrowArrayStream* stream

+0960:     prod = _QueryStreamProducer()

  __pyx_t_2 = NULL;
  __pyx_t_3 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_7questdb_7_client__QueryStreamProducer, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 960, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_1);
  }
  __pyx_v_prod = ((struct __pyx_obj_7questdb_7_client__QueryStreamProducer *)__pyx_t_1);
  __pyx_t_1 = 0;

+0961:     prod.cursor_handle = handle

  __Pyx_INCREF((PyObject *)__pyx_v_handle);
  __Pyx_GIVEREF((PyObject *)__pyx_v_handle);
  __Pyx_GOTREF((PyObject *)__pyx_v_prod->cursor_handle);
  __Pyx_DECREF((PyObject *)__pyx_v_prod->cursor_handle);
  __pyx_v_prod->cursor_handle = __pyx_v_handle;

+0962:     prod.seen_seq = handle._reset_seq

  __pyx_t_4 = __pyx_v_handle->_reset_seq;
  __pyx_v_prod->seen_seq = __pyx_t_4;

+0963:     stream = <ArrowArrayStream*>calloc(1, sizeof(ArrowArrayStream))

  __pyx_v_stream = ((struct ArrowArrayStream *)calloc(1, (sizeof(struct ArrowArrayStream))));

+0964:     if stream == NULL:

  __pyx_t_5 = (__pyx_v_stream == NULL);
  if (unlikely(__pyx_t_5)) {
/* … */
  }

+0965:         raise MemoryError()

    PyErr_NoMemory(); __PYX_ERR(2, 965, __pyx_L1_error)

+0966:     stream.get_schema = _qs_get_schema

  __pyx_v_stream->get_schema = __pyx_f_7questdb_7_client__qs_get_schema;

+0967:     stream.get_next = _qs_get_next

  __pyx_v_stream->get_next = __pyx_f_7questdb_7_client__qs_get_next;

+0968:     stream.get_last_error = _qs_get_last_error

  __pyx_v_stream->get_last_error = __pyx_f_7questdb_7_client__qs_get_last_error;

+0969:     stream.release = _qs_release

  __pyx_v_stream->release = __pyx_f_7questdb_7_client__qs_release;

+0970:     Py_INCREF(prod)

  Py_INCREF(((PyObject *)__pyx_v_prod));

+0971:     stream.private_data = <void*>prod

  __pyx_v_stream->private_data = ((void *)__pyx_v_prod);

+0972:     try:

  {
    /*try:*/ {
/* … */
    }
    __pyx_L4_error:;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
    __pyx_L6_except_error:;
    __Pyx_XGIVEREF(__pyx_t_6);
    __Pyx_XGIVEREF(__pyx_t_7);
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
    goto __pyx_L1_error;
    __pyx_L8_try_return:;
    __Pyx_XGIVEREF(__pyx_t_6);
    __Pyx_XGIVEREF(__pyx_t_7);
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
    goto __pyx_L0;
  }

+0973:         return PyCapsule_New(

      __Pyx_XDECREF(__pyx_r);
/* … */
      __pyx_t_1 = PyCapsule_New(((void *)__pyx_v_stream), __pyx_k_arrow_array_stream, __pyx_f_7questdb_7_client__qs_capsule_destructor); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 973, __pyx_L4_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_r = __pyx_t_1;
      __pyx_t_1 = 0;
      goto __pyx_L8_try_return;

 0974:             <void*>stream, b'arrow_array_stream', _qs_capsule_destructor)

+0975:     except:

    /*except:*/ {
      __Pyx_AddTraceback("questdb._client._make_query_stream_capsule", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(2, 975, __pyx_L6_except_error)
      __Pyx_XGOTREF(__pyx_t_1);
      __Pyx_XGOTREF(__pyx_t_2);
      __Pyx_XGOTREF(__pyx_t_9);

+0976:         Py_DECREF(prod)

      Py_DECREF(((PyObject *)__pyx_v_prod));

+0977:         free(stream)

      free(__pyx_v_stream);

+0978:         raise

      __Pyx_GIVEREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_2);
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_9);
      __pyx_t_1 = 0;  __pyx_t_2 = 0;  __pyx_t_9 = 0; 
      __PYX_ERR(2, 978, __pyx_L6_except_error)
    }

 0979: 

 0980: 

+0981: _NUMPY_NULLABLE_CACHE = None

  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NUMPY_NULLABLE_CACHE, Py_None) < (0)) __PYX_ERR(2, 981, __pyx_L1_error)

 0982: 

 0983: 

+0984: cdef object _numpy_nullable_mapping():

static PyObject *__pyx_f_7questdb_7_client__numpy_nullable_mapping(void) {
  PyObject *__pyx_v_pa = NULL;
  PyObject *__pyx_v_pd = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("questdb._client._numpy_nullable_mapping", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pa);
  __Pyx_XDECREF(__pyx_v_pd);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0985:     """Return a ``types_mapper`` callable that maps Arrow primitives to

 0986:     pandas nullable-extension dtypes (Int64Dtype, Float64Dtype, etc.).

 0987: 

 0988:     Mirrors ``pandas.io._util._arrow_dtype_mapping``'s coverage so that

 0989:     ``to_pandas(dtype_backend="numpy_nullable")`` here matches what

 0990:     ``pd.read_parquet(..., dtype_backend="numpy_nullable")`` produces.

 0991:     Non-primitive Arrow types fall through (mapper returns None) and

 0992:     pyarrow.Table.to_pandas applies its default conversion.

 0993:     """

 0994:     global _NUMPY_NULLABLE_CACHE

+0995:     if _NUMPY_NULLABLE_CACHE is None:

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_NUMPY_NULLABLE_CACHE); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 995, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__pyx_t_1 == Py_None);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
  }

+0996:         import pyarrow as pa

    __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 996, __pyx_L1_error)
    __pyx_t_1 = __pyx_t_3;
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_v_pa = __pyx_t_1;
    __pyx_t_1 = 0;

+0997:         import pandas as pd

    __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pandas, 0, 0, NULL, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 997, __pyx_L1_error)
    __pyx_t_1 = __pyx_t_3;
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_v_pd = __pyx_t_1;
    __pyx_t_1 = 0;

 0998:         _NUMPY_NULLABLE_CACHE = {

+0999:             pa.int8(): pd.Int8Dtype(),

    __pyx_t_1 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_int8, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 999, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Int8Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 999, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1000:             pa.int16(): pd.Int16Dtype(),

    __pyx_t_4 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_int16, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1000, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Int16Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1000, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_5, __pyx_t_4) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1001:             pa.int32(): pd.Int32Dtype(),

    __pyx_t_5 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_int32, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1001, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Int32Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1001, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1002:             pa.int64(): pd.Int64Dtype(),

    __pyx_t_4 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_int64, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1002, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Int64Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1002, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_5, __pyx_t_4) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1003:             pa.uint8(): pd.UInt8Dtype(),

    __pyx_t_5 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uint8, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1003, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_UInt8Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1003, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1004:             pa.uint16(): pd.UInt16Dtype(),

    __pyx_t_4 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uint16, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1004, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_UInt16Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1004, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_5, __pyx_t_4) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1005:             pa.uint32(): pd.UInt32Dtype(),

    __pyx_t_5 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uint32, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_UInt32Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1005, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1006:             pa.uint64(): pd.UInt64Dtype(),

    __pyx_t_4 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uint64, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1006, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_UInt64Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1006, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_5, __pyx_t_4) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1007:             pa.float32(): pd.Float32Dtype(),

    __pyx_t_5 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_float32, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1007, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Float32Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1007, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1008:             pa.float64(): pd.Float64Dtype(),

    __pyx_t_4 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_float64, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1008, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Float64Dtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1008, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_5, __pyx_t_4) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1009:             pa.bool_(): pd.BooleanDtype(),

    __pyx_t_5 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_bool_2, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1009, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_BooleanDtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1009, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1010:             pa.string(): pd.StringDtype(),

    __pyx_t_4 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_string, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1010, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_StringDtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1010, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_5, __pyx_t_4) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1011:             pa.large_string(): pd.StringDtype(),

    __pyx_t_5 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_large_string, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1011, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_7 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_StringDtype, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1011, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    if (PyDict_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(2, 999, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1012:         }.get

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1012, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NUMPY_NULLABLE_CACHE, __pyx_t_5) < (0)) __PYX_ERR(2, 998, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1013:     return _NUMPY_NULLABLE_CACHE

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_NUMPY_NULLABLE_CACHE); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1013, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

 1014: 

 1015: 

+1016: cdef object _table_shared_symbol_dict(object table):

static PyObject *__pyx_f_7questdb_7_client__table_shared_symbol_dict(PyObject *__pyx_v_table) {
  PyObject *__pyx_v_pa = NULL;
  PyObject *__pyx_v_schema = 0;
  int __pyx_v_changed;
  PyObject *__pyx_v_cols = 0;
  PyObject *__pyx_v_fields = 0;
  PyObject *__pyx_v_field = 0;
  PyObject *__pyx_v_ty = 0;
  PyObject *__pyx_v_col = 0;
  PyObject *__pyx_v_shared = 0;
  PyObject *__pyx_v_signed_ty = 0;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_n;
  Py_ssize_t __pyx_8genexpr1__pyx_v_j;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_19);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_AddTraceback("questdb._client._table_shared_symbol_dict", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pa);
  __Pyx_XDECREF(__pyx_v_schema);
  __Pyx_XDECREF(__pyx_v_cols);
  __Pyx_XDECREF(__pyx_v_fields);
  __Pyx_XDECREF(__pyx_v_field);
  __Pyx_XDECREF(__pyx_v_ty);
  __Pyx_XDECREF(__pyx_v_col);
  __Pyx_XDECREF(__pyx_v_shared);
  __Pyx_XDECREF(__pyx_v_signed_ty);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1017:     """Collapse every dictionary (SYMBOL) column so all chunks share ONE

 1018:     dictionary, and recast its index to signed int32.

 1019: 

 1020:     QuestDB SYMBOL egresses as ``dictionary(uint32, utf8)``, one chunk per wire

 1021:     batch, each carrying the full append-only connection dict with global,

 1022:     query-stable codes — so the last chunk's dictionary is the largest and

 1023:     covers every code (same invariant as ``_polars_dict_codes_cats``). A generic

 1024:     consumer (``Table.to_pandas`` / a foreign Arrow reader) otherwise re-unifies

 1025:     the per-batch dictionaries — ``O(batches × cardinality)``, which dominates

 1026:     high-cardinality SYMBOL egress. Re-pointing every chunk at that one shared

 1027:     dictionary makes the unify a no-op (codes are already valid against the

 1028:     superset). The index is also recast to int32 because pandas rejects unsigned

 1029:     dictionary indices (symbol cardinality fits int32). Returns the table

 1030:     unchanged when no column is a dictionary.

 1031:     """

+1032:     import pyarrow as pa

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1032, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_pa = __pyx_t_1;
  __pyx_t_1 = 0;

+1033:     cdef object schema = table.schema

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_table, __pyx_mstate_global->__pyx_n_u_schema); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1033, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_schema = __pyx_t_1;
  __pyx_t_1 = 0;

+1034:     cdef bint changed = False

  __pyx_v_changed = 0;

+1035:     cdef list cols = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1035, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_cols = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1036:     cdef list fields = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1036, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_fields = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 1037:     cdef object field, ty, col, shared, signed_ty

 1038:     cdef Py_ssize_t i, j, n

+1039:     for i in range(table.num_columns):

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_table, __pyx_mstate_global->__pyx_n_u_num_columns); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1039, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1039, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

+1040:         field = schema.field(i)

    __pyx_t_6 = __pyx_v_schema;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_7 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1040, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_7};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_field, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1040, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_XDECREF_SET(__pyx_v_field, __pyx_t_1);
    __pyx_t_1 = 0;

+1041:         ty = field.type

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1041, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_ty, __pyx_t_1);
    __pyx_t_1 = 0;

+1042:         if not pa.types.is_dictionary(ty):

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1042, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __pyx_t_6;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_ty};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_dictionary, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1042, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 1042, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_10 = (!__pyx_t_9);
    if (__pyx_t_10) {
/* … */
    }

+1043:             cols.append(table.column(i))

      __pyx_t_6 = __pyx_v_table;
      __Pyx_INCREF(__pyx_t_6);
      __pyx_t_7 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1043, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_8 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_7};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_column_2, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1043, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_cols, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1043, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1044:             fields.append(field)

      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_v_field); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1044, __pyx_L1_error)

+1045:             continue

      goto __pyx_L3_continue;

+1046:         changed = True

    __pyx_v_changed = 1;

+1047:         col = table.column(i)

    __pyx_t_7 = __pyx_v_table;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_6 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1047, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_column_2, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1047, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_XDECREF_SET(__pyx_v_col, __pyx_t_1);
    __pyx_t_1 = 0;

+1048:         signed_ty = pa.dictionary(pa.int32(), ty.value_type, ty.ordered)

    __pyx_t_6 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_12 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_12);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL};
      __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_int32, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1048, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_ty, __pyx_mstate_global->__pyx_n_u_value_type); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1048, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_ty, __pyx_mstate_global->__pyx_n_u_ordered); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1048, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_t_7, __pyx_t_12, __pyx_t_13};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dictionary, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1048, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_XDECREF_SET(__pyx_v_signed_ty, __pyx_t_1);
    __pyx_t_1 = 0;

+1049:         n = col.num_chunks

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_col, __pyx_mstate_global->__pyx_n_u_num_chunks); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1049, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_14 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_14 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1049, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_n = __pyx_t_14;

+1050:         if n == 0:

    __pyx_t_10 = (__pyx_v_n == 0);
    if (__pyx_t_10) {
/* … */
      goto __pyx_L6;
    }

+1051:             cols.append(col.cast(signed_ty))

      __pyx_t_13 = __pyx_v_col;
      __Pyx_INCREF(__pyx_t_13);
      __pyx_t_8 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_v_signed_ty};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_cast, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1051, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_cols, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1051, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1052:         else:

 1053:             # Append-only => the last chunk's dict is the superset; rebase every

 1054:             # chunk's (int32-recast) codes onto it so they share one dictionary.

+1055:             shared = col.chunk(n - 1).dictionary

    /*else*/ {
      __pyx_t_13 = __pyx_v_col;
      __Pyx_INCREF(__pyx_t_13);
      __pyx_t_12 = PyLong_FromSsize_t((__pyx_v_n - 1)); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1055, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_8 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_12};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_chunk, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1055, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_dictionary); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1055, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF_SET(__pyx_v_shared, __pyx_t_12);
      __pyx_t_12 = 0;

+1056:             cols.append(pa.chunked_array(

      __pyx_t_1 = __pyx_v_pa;
      __Pyx_INCREF(__pyx_t_1);
      { /* enter inner scope */
/* … */
      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_cols, __pyx_t_12); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1056, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    }
    __pyx_L6:;

+1057:                 [pa.DictionaryArray.from_arrays(

        __pyx_t_13 = PyList_New(0); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1057, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
/* … */
          __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_DictionaryArray); if (unlikely(!__pyx_t_17)) __PYX_ERR(2, 1057, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
          __pyx_t_6 = __pyx_t_17;
          __Pyx_INCREF(__pyx_t_6);

+1058:                     col.chunk(j).indices.cast(pa.int32()), shared)

          __pyx_t_21 = __pyx_v_col;
          __Pyx_INCREF(__pyx_t_21);
          __pyx_t_22 = PyLong_FromSsize_t(__pyx_8genexpr1__pyx_v_j); if (unlikely(!__pyx_t_22)) __PYX_ERR(2, 1058, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __pyx_t_8 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_21, __pyx_t_22};
            __pyx_t_20 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_chunk, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 1058, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
          }
          __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_indices); if (unlikely(!__pyx_t_22)) __PYX_ERR(2, 1058, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_22);
          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
          __pyx_t_19 = __pyx_t_22;
          __Pyx_INCREF(__pyx_t_19);
          __pyx_t_21 = __pyx_v_pa;
          __Pyx_INCREF(__pyx_t_21);
          __pyx_t_8 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_21, NULL};
            __pyx_t_20 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_int32, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
            if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 1058, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
          }
          __pyx_t_8 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_19, __pyx_t_20};
            __pyx_t_18 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_cast, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
            if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 1058, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_18);
          }
          __pyx_t_8 = 0;
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_18, __pyx_v_shared};
            __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrays, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
            if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1057, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_7);
          }
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_13, (PyObject*)__pyx_t_7))) __PYX_ERR(2, 1057, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        }
      } /* exit inner scope */

+1059:                  for j in range(n)],

        __pyx_t_14 = __pyx_v_n;
        __pyx_t_15 = __pyx_t_14;
        for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) {
          __pyx_8genexpr1__pyx_v_j = __pyx_t_16;

+1060:                 type=signed_ty))

      __pyx_t_8 = 0;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, __pyx_t_13};
        __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1056, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_type, __pyx_v_signed_ty, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1056, __pyx_L1_error)
        __pyx_t_12 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_chunked_array, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1056, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_12);
      }

+1061:         fields.append(field.with_type(signed_ty))

    __pyx_t_7 = __pyx_v_field;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_signed_ty};
      __pyx_t_12 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_with_type, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1061, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_12); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1061, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_L3_continue:;
  }

+1062:     if not changed:

  __pyx_t_10 = (!__pyx_v_changed);
  if (__pyx_t_10) {
/* … */
  }

+1063:         return table

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_table);
    __pyx_r = __pyx_v_table;
    goto __pyx_L0;

+1064:     return pa.Table.from_arrays(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_Table); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1064, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __pyx_t_7 = __pyx_t_13;
  __Pyx_INCREF(__pyx_t_7);

+1065:         cols, schema=pa.schema(fields, metadata=schema.metadata))

  __pyx_t_17 = __pyx_v_pa;
  __Pyx_INCREF(__pyx_t_17);
  __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_schema, __pyx_mstate_global->__pyx_n_u_metadata); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 1065, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_18);
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_17, __pyx_v_fields};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1065, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_18, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1065, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_schema, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1065, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_v_cols};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1064, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_schema, __pyx_t_1, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1064, __pyx_L1_error)
    __pyx_t_12 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrays, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1064, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
  }
  __pyx_r = __pyx_t_12;
  __pyx_t_12 = 0;
  goto __pyx_L0;

 1066: 

 1067: 

 1068: cdef dict _KIND_NAMES = {

+1069:     <int>qwp_reader_column_kind_boolean: 'boolean',

  __pyx_t_4 = __Pyx_PyDict_NewPresized(23); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_boolean)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_boolean) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1070:     <int>qwp_reader_column_kind_byte: 'byte',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_byte)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1070, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_byte) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1071:     <int>qwp_reader_column_kind_short: 'short',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_short)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1071, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_short) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1072:     <int>qwp_reader_column_kind_int: 'int',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_int)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1072, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1073:     <int>qwp_reader_column_kind_long: 'long',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_long)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_long) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1074:     <int>qwp_reader_column_kind_float: 'float',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_float)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1074, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_float) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1075:     <int>qwp_reader_column_kind_double: 'double',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_double)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1075, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_double) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1076:     <int>qwp_reader_column_kind_char: 'char',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_char)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1076, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_char) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1077:     <int>qwp_reader_column_kind_ipv4: 'ipv4',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_ipv4)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1077, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_ipv4) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1078:     <int>qwp_reader_column_kind_timestamp: 'timestamp',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_timestamp)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1078, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_timestamp) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1079:     <int>qwp_reader_column_kind_timestamp_nanos: 'timestamp_ns',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_timestamp_nanos)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_timestamp_ns) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1080:     <int>qwp_reader_column_kind_date: 'date',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_date)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1080, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_date) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1081:     <int>qwp_reader_column_kind_uuid: 'uuid',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_uuid)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1081, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_uuid_2) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1082:     <int>qwp_reader_column_kind_long256: 'long256',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_long256)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1082, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_long256) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1083:     <int>qwp_reader_column_kind_geohash: 'geohash',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_geohash)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1083, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_geohash) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1084:     <int>qwp_reader_column_kind_varchar: 'varchar',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_varchar)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1084, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_varchar) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1085:     <int>qwp_reader_column_kind_binary: 'binary',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_binary)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1085, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_binary) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1086:     <int>qwp_reader_column_kind_symbol: 'symbol',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_symbol)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1086, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_symbol) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1087:     <int>qwp_reader_column_kind_double_array: 'double_array',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_double_array)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1087, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_double_array) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1088:     <int>qwp_reader_column_kind_long_array: 'long_array',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_long_array)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1088, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_long_array) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1089:     <int>qwp_reader_column_kind_decimal64: 'decimal',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_decimal64)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1089, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_decimal) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1090:     <int>qwp_reader_column_kind_decimal128: 'decimal',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_decimal128)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1090, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_decimal) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+1091:     <int>qwp_reader_column_kind_decimal256: 'decimal',

  __pyx_t_15 = __Pyx_PyLong_From_int(((int)qwp_reader_column_kind_decimal256)); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1091, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_n_u_decimal) < (0)) __PYX_ERR(2, 1069, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __Pyx_XGOTREF(__pyx_v_7questdb_7_client__KIND_NAMES);
  __Pyx_DECREF_SET(__pyx_v_7questdb_7_client__KIND_NAMES, ((PyObject*)__pyx_t_4));
  __Pyx_GIVEREF(__pyx_t_4);
  __pyx_t_4 = 0;

 1092: }

 1093: 

 1094: 

+1095: cdef object _UUID_MODULE = None

  __Pyx_INCREF(Py_None);
  __Pyx_XGOTREF(__pyx_v_7questdb_7_client__UUID_MODULE);
  __Pyx_DECREF_SET(__pyx_v_7questdb_7_client__UUID_MODULE, Py_None);
  __Pyx_GIVEREF(Py_None);

+1096: cdef object _DECIMAL_TYPE = None

  __Pyx_INCREF(Py_None);
  __Pyx_XGOTREF(__pyx_v_7questdb_7_client__DECIMAL_TYPE);
  __Pyx_DECREF_SET(__pyx_v_7questdb_7_client__DECIMAL_TYPE, Py_None);
  __Pyx_GIVEREF(Py_None);

 1097: 

 1098: 

+1099: cdef object _uuid_module():

static PyObject *__pyx_f_7questdb_7_client__uuid_module(void) {
  PyObject *__pyx_v_uuid = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("questdb._client._uuid_module", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_uuid);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1100:     global _UUID_MODULE

+1101:     if _UUID_MODULE is None:

  __pyx_t_1 = (__pyx_v_7questdb_7_client__UUID_MODULE == Py_None);
  if (__pyx_t_1) {
/* … */
  }

+1102:         import uuid

    __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_uuid_2, 0, 0, NULL, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1102, __pyx_L1_error)
    __pyx_t_2 = __pyx_t_3;
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_v_uuid = __pyx_t_2;
    __pyx_t_2 = 0;

+1103:         _UUID_MODULE = uuid

    __Pyx_INCREF(__pyx_v_uuid);
    __Pyx_XGOTREF(__pyx_v_7questdb_7_client__UUID_MODULE);
    __Pyx_DECREF_SET(__pyx_v_7questdb_7_client__UUID_MODULE, __pyx_v_uuid);
    __Pyx_GIVEREF(__pyx_v_uuid);

+1104:     return _UUID_MODULE

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_7questdb_7_client__UUID_MODULE);
  __pyx_r = __pyx_v_7questdb_7_client__UUID_MODULE;
  goto __pyx_L0;

 1105: 

 1106: 

+1107: cdef object _decimal_type():

static PyObject *__pyx_f_7questdb_7_client__decimal_type(void) {
  PyObject *__pyx_v_Decimal = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("questdb._client._decimal_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_Decimal);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1108:     global _DECIMAL_TYPE

+1109:     if _DECIMAL_TYPE is None:

  __pyx_t_1 = (__pyx_v_7questdb_7_client__DECIMAL_TYPE == Py_None);
  if (__pyx_t_1) {
/* … */
  }

+1110:         from decimal import Decimal

    {
      PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Decimal};
      __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_decimal, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1110, __pyx_L1_error)
    }
    __pyx_t_2 = __pyx_t_3;
    __Pyx_GOTREF(__pyx_t_2);
    {
      PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Decimal};
      __pyx_t_4 = 0; {
        __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_4]); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1110, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        switch (__pyx_t_4) {
          case 0:
          __Pyx_INCREF(__pyx_t_5);
          __pyx_v_Decimal = __pyx_t_5;
          break;
          default:;
        }
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1111:         _DECIMAL_TYPE = Decimal

    __Pyx_INCREF(__pyx_v_Decimal);
    __Pyx_XGOTREF(__pyx_v_7questdb_7_client__DECIMAL_TYPE);
    __Pyx_DECREF_SET(__pyx_v_7questdb_7_client__DECIMAL_TYPE, __pyx_v_Decimal);
    __Pyx_GIVEREF(__pyx_v_Decimal);

+1112:     return _DECIMAL_TYPE

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_7questdb_7_client__DECIMAL_TYPE);
  __pyx_r = __pyx_v_7questdb_7_client__DECIMAL_TYPE;
  goto __pyx_L0;

 1113: 

 1114: 

+1115: cdef int _reader_check(bint ok, questdb_error** err, str what) except -1:

static int __pyx_f_7questdb_7_client__reader_check(int __pyx_v_ok, questdb_error **__pyx_v_err, PyObject *__pyx_v_what) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("questdb._client._reader_check", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1116:     # By address, not value: reading `err` in the same argument list as the

 1117:     # FFI call that writes it is indeterminately sequenced (C11 6.5.2.2p10).

+1118:     if ok:

  if (__pyx_v_ok) {
/* … */
  }

+1119:         return 0

    __pyx_r = 0;
    goto __pyx_L0;

+1120:     if err[0] != NULL:

  __pyx_t_1 = ((__pyx_v_err[0]) != NULL);
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+1121:         raise _reader_err_to_py(err[0])

    __pyx_t_2 = __pyx_f_7questdb_7_client__reader_err_to_py((__pyx_v_err[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1121, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1121, __pyx_L1_error)

+1122:     raise QuestDBError(

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+1123:         QuestDBErrorCode.ServerFlushError,

  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1123, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1123, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1124:         what + ' returned false without err_out')

  __pyx_t_5 = __Pyx_PyUnicode_ConcatSafe(__pyx_v_what, __pyx_mstate_global->__pyx_kp_u_returned_false_without_err_out); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
    __pyx_t_7 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_6, __pyx_t_5};
    __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_Raise(__pyx_t_2, 0, 0, 0);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __PYX_ERR(2, 1122, __pyx_L1_error)

 1125: 

 1126: 

+1127: cdef object _numpy_dtype_for_kind(qwp_reader_column_kind kind, object np):

static PyObject *__pyx_f_7questdb_7_client__numpy_dtype_for_kind(enum qwp_reader_column_kind __pyx_v_kind, PyObject *__pyx_v_np) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("questdb._client._numpy_dtype_for_kind", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1128:     if kind == qwp_reader_column_kind_boolean:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_boolean);
  if (__pyx_t_1) {
/* … */
  }

+1129:         return np.dtype(np.bool_)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_bool_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1129, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1129, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1130:     if kind == qwp_reader_column_kind_byte:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_byte);
  if (__pyx_t_1) {
/* … */
  }

+1131:         return np.dtype(np.int8)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_int8); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1131, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1131, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1132:     if kind == qwp_reader_column_kind_short:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_short);
  if (__pyx_t_1) {
/* … */
  }

+1133:         return np.dtype(np.int16)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_int16); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1133, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1133, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1134:     if kind == qwp_reader_column_kind_int:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_int);
  if (__pyx_t_1) {
/* … */
  }

+1135:         return np.dtype(np.int32)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_int32); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1135, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1135, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1136:     if kind == qwp_reader_column_kind_long:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_long);
  if (__pyx_t_1) {
/* … */
  }

+1137:         return np.dtype(np.int64)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_int64); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1137, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1137, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1138:     if kind == qwp_reader_column_kind_float:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_float);
  if (__pyx_t_1) {
/* … */
  }

+1139:         return np.dtype(np.float32)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_float32); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1139, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1139, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1140:     if kind == qwp_reader_column_kind_double:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_double);
  if (__pyx_t_1) {
/* … */
  }

+1141:         return np.dtype(np.float64)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_float64); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1141, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1141, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1142:     if kind == qwp_reader_column_kind_char:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_char);
  if (__pyx_t_1) {
/* … */
  }

+1143:         return np.dtype(np.uint16)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint16); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1143, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1143, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1144:     if kind == qwp_reader_column_kind_ipv4:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_ipv4);
  if (__pyx_t_1) {
/* … */
  }

+1145:         return np.dtype(np.uint32)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint32); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1145, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1145, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1146:     if kind == qwp_reader_column_kind_timestamp:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_timestamp);
  if (__pyx_t_1) {
/* … */
  }

+1147:         return np.dtype('datetime64[us]')

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_datetime64_us};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1147, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1148:     if kind == qwp_reader_column_kind_timestamp_nanos:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_timestamp_nanos);
  if (__pyx_t_1) {
/* … */
  }

+1149:         return np.dtype('datetime64[ns]')

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_datetime64_ns};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1149, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1150:     if kind == qwp_reader_column_kind_date:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_date);
  if (__pyx_t_1) {
/* … */
  }

+1151:         return np.dtype('datetime64[ms]')

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_datetime64_ms};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1151, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1152:     return None

  __Pyx_XDECREF(__pyx_r);
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;

 1153: 

 1154: 

+1155: cdef object _numpy_fixed_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_fixed_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, enum qwp_reader_column_kind __pyx_v_kind, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  PyObject *__pyx_v_dtype = 0;
  size_t __pyx_v_itemsize;
  CYTHON_UNUSED Py_ssize_t __pyx_v_nbytes;
  unsigned char *__pyx_v_src;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF((PyObject *)__pyx_t_13);
  __Pyx_AddTraceback("questdb._client._numpy_fixed_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_dtype);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1156:         const qwp_reader_batch* batch,

 1157:         size_t col_idx,

 1158:         qwp_reader_column_kind kind,

 1159:         size_t row_count,

 1160:         object np):

 1161:     cdef qwp_reader_column_data cd

+1162:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

+1163:     cdef object dtype = _numpy_dtype_for_kind(kind, np)

  __pyx_t_1 = __pyx_f_7questdb_7_client__numpy_dtype_for_kind(__pyx_v_kind, __pyx_v_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_dtype = __pyx_t_1;
  __pyx_t_1 = 0;

 1164:     cdef size_t itemsize

 1165:     cdef Py_ssize_t nbytes

 1166:     cdef unsigned char* src

+1167:     if dtype is None:

  __pyx_t_2 = (__pyx_v_dtype == Py_None);
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+1168:         raise QuestDBError(

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1168, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+1169:             QuestDBErrorCode.InvalidApiCall,

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1169, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1169, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1170:             'numpy egress does not support column kind 0x{:02X} yet'.format(

    __pyx_t_7 = __pyx_mstate_global->__pyx_kp_u_numpy_egress_does_not_support_co;
    __Pyx_INCREF(__pyx_t_7);

+1171:                 <int>kind))

    __pyx_t_8 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1171, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1170, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_6, __pyx_t_5};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1168, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 1168, __pyx_L1_error)

+1172:     _reader_check(

  __pyx_t_10 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 1172, __pyx_L1_error)

 1173:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1174:         'qwp_reader_batch_column_data')

+1175:     itemsize = dtype.itemsize

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_mstate_global->__pyx_n_u_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = __Pyx_PyLong_As_size_t(__pyx_t_1); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1175, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_itemsize = __pyx_t_9;

+1176:     if cd.value_stride != itemsize:

  __pyx_t_2 = (__pyx_v_cd.value_stride != __pyx_v_itemsize);
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+1177:         raise QuestDBError(

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1177, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);

+1178:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1178, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1178, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+1179:             'column kind 0x{:02X} wire stride {} != numpy itemsize {}'.format(

    __pyx_t_8 = __pyx_mstate_global->__pyx_kp_u_column_kind_0x_02X_wire_stride_n;
    __Pyx_INCREF(__pyx_t_8);

+1180:                 <int>kind, cd.value_stride, itemsize))

    __pyx_t_7 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1180, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_11 = __Pyx_PyLong_FromSize_t(__pyx_v_cd.value_stride); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1180, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_12 = __Pyx_PyLong_FromSize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1180, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_t_7, __pyx_t_11, __pyx_t_12};
      __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1179, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_6};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1177, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 1177, __pyx_L1_error)

+1181:     if row_count == 0:

  __pyx_t_2 = (__pyx_v_row_count == 0);
  if (__pyx_t_2) {
/* … */
  }

+1182:         return np.empty(0, dtype=dtype)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0};
      __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1182, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_v_dtype, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1182, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1182, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

+1183:     if cd.values == NULL:

  __pyx_t_2 = (__pyx_v_cd.values == NULL);
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+1184:         raise QuestDBError(

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1184, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);

+1185:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1185, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1185, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1186:             'column kind 0x{:02X} has {} rows but no values buffer'.format(

    __pyx_t_12 = __pyx_mstate_global->__pyx_kp_u_column_kind_0x_02X_has_rows_but;
    __Pyx_INCREF(__pyx_t_12);

+1187:                 <int>kind, row_count))

    __pyx_t_11 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1187, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_7 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1187, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_12, __pyx_t_11, __pyx_t_7};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1186, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_3};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1184, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 1184, __pyx_L1_error)

+1188:     nbytes = <Py_ssize_t>(row_count * cd.value_stride)

  __pyx_v_nbytes = ((Py_ssize_t)(__pyx_v_row_count * __pyx_v_cd.value_stride));

+1189:     src = <unsigned char*>cd.values

  __pyx_v_src = ((unsigned char *)__pyx_v_cd.values);

+1190:     if kind == qwp_reader_column_kind_boolean:

  __pyx_t_2 = (__pyx_v_kind == qwp_reader_column_kind_boolean);
  if (__pyx_t_2) {
/* … */
  }

+1191:         return np.frombuffer((<unsigned char[:nbytes]>src), dtype=np.uint8) != 0

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_5);
    if (!__pyx_v_src) {
      PyErr_SetString(PyExc_ValueError,"Cannot create cython.array from NULL pointer");
      __PYX_ERR(2, 1191, __pyx_L1_error)
    }
    __pyx_t_4 = __pyx_format_from_typeinfo(&__Pyx_TypeInfo_unsigned_char); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1191, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = Py_BuildValue("("  __PYX_BUILD_PY_SSIZE_T  ")", ((Py_ssize_t)__pyx_v_nbytes)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1191, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    #if CYTHON_COMPILING_IN_LIMITED_API
    __pyx_t_14 = PyBytes_AsString(__pyx_t_4); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 1191, __pyx_L1_error)
    #else
    __pyx_t_14 = PyBytes_AS_STRING(__pyx_t_4);
    #endif
    __pyx_t_13 = __pyx_array_new(__pyx_t_3, sizeof(unsigned char), __pyx_t_14, "c", (char *) __pyx_v_src); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1191, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_13);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint8); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1191, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, ((PyObject *)__pyx_t_13)};
      __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1191, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_frombuffer, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3);
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF((PyObject *)__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1191, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_3 = __Pyx_PyLong_NeObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1191, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_r = __pyx_t_3;
    __pyx_t_3 = 0;
    goto __pyx_L0;

+1192:     return np.frombuffer((<unsigned char[:nbytes]>src), dtype=dtype).copy()

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_5);
  if (!__pyx_v_src) {
    PyErr_SetString(PyExc_ValueError,"Cannot create cython.array from NULL pointer");
    __PYX_ERR(2, 1192, __pyx_L1_error)
  }
  __pyx_t_7 = __pyx_format_from_typeinfo(&__Pyx_TypeInfo_unsigned_char); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_6 = Py_BuildValue("("  __PYX_BUILD_PY_SSIZE_T  ")", ((Py_ssize_t)__pyx_v_nbytes)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  #if CYTHON_COMPILING_IN_LIMITED_API
  __pyx_t_14 = PyBytes_AsString(__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 1192, __pyx_L1_error)
  #else
  __pyx_t_14 = PyBytes_AS_STRING(__pyx_t_7);
  #endif
  __pyx_t_13 = __pyx_array_new(__pyx_t_6, sizeof(unsigned char), __pyx_t_14, "c", (char *) __pyx_v_src); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1192, __pyx_L1_error)
  __Pyx_GOTREF((PyObject *)__pyx_t_13);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, ((PyObject *)__pyx_t_13)};
    __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1192, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_v_dtype, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1192, __pyx_L1_error)
    __pyx_t_4 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_frombuffer, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF((PyObject *)__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1192, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_1 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1192, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 1193: 

 1194: 

+1195: cdef inline void_int _obj_chunk_set(

static CYTHON_INLINE __pyx_t_7questdb_7_client_void_int __pyx_f_7questdb_7_client__obj_chunk_set(PyArrayObject *__pyx_v_out, size_t __pyx_v_r, PyObject *__pyx_v_v) {
  __pyx_t_7questdb_7_client_void_int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("questdb._client._obj_chunk_set", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  return __pyx_r;
}

 1196:         cnp.ndarray out, size_t r, object v) except -1:

 1197:     # np.empty(dtype=object) initialises every slot to None, so null rows are

 1198:     # left untouched and a mid-loop raise leaves the array safe to release.

+1199:     cnp.PyArray_SETITEM(out, cnp.PyArray_GETPTR1(out, <cnp.npy_intp>r), v)

  __pyx_t_1 = PyArray_SETITEM(__pyx_v_out, PyArray_GETPTR1(__pyx_v_out, ((npy_intp)__pyx_v_r)), __pyx_v_v); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 1199, __pyx_L1_error)

 1200: 

 1201: 

+1202: cdef object _numpy_varlen_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_varlen_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, enum qwp_reader_column_kind __pyx_v_kind, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  uint32_t const *__pyx_v_offsets;
  uint8_t const *__pyx_v_data;
  uint8_t const *__pyx_v_validity;
  size_t __pyx_v_r;
  uint32_t __pyx_v_start;
  uint32_t __pyx_v_end;
  PyArrayObject *__pyx_v_out = 0;
  int __pyx_v_is_binary;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("questdb._client._numpy_varlen_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_out);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1203:         const qwp_reader_batch* batch,

 1204:         size_t col_idx,

 1205:         qwp_reader_column_kind kind,

 1206:         size_t row_count,

 1207:         object np):

 1208:     cdef qwp_reader_column_data cd

+1209:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1210:     cdef const uint32_t* offsets

 1211:     cdef const uint8_t* data

 1212:     cdef const uint8_t* validity

 1213:     cdef size_t r

 1214:     cdef uint32_t start

 1215:     cdef uint32_t end

 1216:     cdef cnp.ndarray out

+1217:     cdef bint is_binary = kind == qwp_reader_column_kind_binary

  __pyx_v_is_binary = (__pyx_v_kind == qwp_reader_column_kind_binary);

+1218:     _reader_check(

  __pyx_t_1 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 1218, __pyx_L1_error)

 1219:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1220:         'qwp_reader_batch_column_data')

+1221:     out = np.empty(row_count, dtype=object)

  __pyx_t_3 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1221, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_builtin_object, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1221, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1221, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 1221, __pyx_L1_error)
  __pyx_v_out = ((PyArrayObject *)__pyx_t_2);
  __pyx_t_2 = 0;

+1222:     if row_count == 0:

  __pyx_t_7 = (__pyx_v_row_count == 0);
  if (__pyx_t_7) {
/* … */
  }

+1223:         return out

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF((PyObject *)__pyx_v_out);
    __pyx_r = ((PyObject *)__pyx_v_out);
    goto __pyx_L0;

+1224:     if cd.var_offsets == NULL:

  __pyx_t_7 = (__pyx_v_cd.var_offsets == NULL);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1225:         raise QuestDBError(

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1225, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+1226:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1226, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1226, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1227:             'column kind 0x{:02X} has {} rows but no offset table'.format(

    __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u_column_kind_0x_02X_has_rows_but_2;
    __Pyx_INCREF(__pyx_t_9);

+1228:                 <int>kind, row_count))

    __pyx_t_10 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_11 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_10, __pyx_t_11};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1227, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_8, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1225, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1225, __pyx_L1_error)

+1229:     offsets = cd.var_offsets

  __pyx_t_12 = __pyx_v_cd.var_offsets;
  __pyx_v_offsets = __pyx_t_12;

+1230:     data = cd.var_data

  __pyx_t_13 = __pyx_v_cd.var_data;
  __pyx_v_data = __pyx_t_13;

+1231:     if data == NULL and cd.var_data_len > 0:

  __pyx_t_14 = (__pyx_v_data == NULL);
  if (__pyx_t_14) {
  } else {
    __pyx_t_7 = __pyx_t_14;
    goto __pyx_L6_bool_binop_done;
  }
  __pyx_t_14 = (__pyx_v_cd.var_data_len > 0);
  __pyx_t_7 = __pyx_t_14;
  __pyx_L6_bool_binop_done:;
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1232:         raise QuestDBError(

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1232, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);

+1233:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1233, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1233, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+1234:             'column kind 0x{:02X} has {} rows but no data buffer'.format(

    __pyx_t_11 = __pyx_mstate_global->__pyx_kp_u_column_kind_0x_02X_has_rows_but_3;
    __Pyx_INCREF(__pyx_t_11);

+1235:                 <int>kind, row_count))

    __pyx_t_10 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1235, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_9 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1235, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_t_10, __pyx_t_9};
      __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1234, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
    }
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_8};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1232, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1232, __pyx_L1_error)

+1236:     validity = cd.validity

  __pyx_t_15 = __pyx_v_cd.validity;
  __pyx_v_validity = __pyx_t_15;

+1237:     for r in range(row_count):

  __pyx_t_5 = __pyx_v_row_count;
  __pyx_t_16 = __pyx_t_5;
  for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
    __pyx_v_r = __pyx_t_17;

+1238:         if validity != NULL and ((validity[r >> 3] >> (r & 7)) & 1):

    __pyx_t_14 = (__pyx_v_validity != NULL);
    if (__pyx_t_14) {
    } else {
      __pyx_t_7 = __pyx_t_14;
      goto __pyx_L11_bool_binop_done;
    }
    __pyx_t_14 = ((((__pyx_v_validity[(__pyx_v_r >> 3)]) >> (__pyx_v_r & 7)) & 1) != 0);
    __pyx_t_7 = __pyx_t_14;
    __pyx_L11_bool_binop_done:;
    if (__pyx_t_7) {
/* … */
    }

+1239:             continue

      goto __pyx_L8_continue;

+1240:         start = offsets[r]

    __pyx_v_start = (__pyx_v_offsets[__pyx_v_r]);

+1241:         end = offsets[r + 1]

    __pyx_v_end = (__pyx_v_offsets[(__pyx_v_r + 1)]);

+1242:         if end < start or end > cd.var_data_len:

    __pyx_t_14 = (__pyx_v_end < __pyx_v_start);
    if (!__pyx_t_14) {
    } else {
      __pyx_t_7 = __pyx_t_14;
      goto __pyx_L14_bool_binop_done;
    }
    __pyx_t_14 = (__pyx_v_end > __pyx_v_cd.var_data_len);
    __pyx_t_7 = __pyx_t_14;
    __pyx_L14_bool_binop_done:;
    if (unlikely(__pyx_t_7)) {
/* … */
    }

+1243:             raise QuestDBError(

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1243, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);

+1244:                 QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1244, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1244, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+1245:                 'corrupt varlen offsets in column kind 0x{:02X}'.format(

      __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u_corrupt_varlen_offsets_in_column;
      __Pyx_INCREF(__pyx_t_9);

+1246:                     <int>kind))

      __pyx_t_10 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1246, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_18 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_10};
        __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_18, (2-__pyx_t_18) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1245, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
      }
      __pyx_t_18 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_8))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
        __pyx_t_18 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_4, __pyx_t_6};
        __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_18, (3-__pyx_t_18) | (__pyx_t_18*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1243, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_Raise(__pyx_t_2, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __PYX_ERR(2, 1243, __pyx_L1_error)

+1247:         if end > start:

    __pyx_t_7 = (__pyx_v_end > __pyx_v_start);
    if (__pyx_t_7) {
/* … */
      goto __pyx_L16;
    }

+1248:             if is_binary:

      if (__pyx_v_is_binary) {
/* … */
        goto __pyx_L17;
      }

+1249:                 _obj_chunk_set(out, r, PyBytes_FromStringAndSize(

        __pyx_t_2 = PyBytes_FromStringAndSize(((char const *)(__pyx_v_data + __pyx_v_start)), ((Py_ssize_t)(__pyx_v_end - __pyx_v_start))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1249, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_19 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_t_2); if (unlikely(__pyx_t_19 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1249, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 1250:                     <const char*>(data + start), <Py_ssize_t>(end - start)))

 1251:             else:

+1252:                 _obj_chunk_set(out, r, PyUnicode_FromStringAndSize(

      /*else*/ {
/* … */
        __pyx_t_2 = PyUnicode_FromStringAndSize(((char const *)(__pyx_v_data + __pyx_v_start)), ((Py_ssize_t)(__pyx_v_end - __pyx_v_start))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1252, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
/* … */
        __pyx_t_19 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_t_2); if (unlikely(__pyx_t_19 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1252, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      }
      __pyx_L17:;

 1253:                     <const char*>(data + start), <Py_ssize_t>(end - start)))

 1254:         else:

+1255:             _obj_chunk_set(out, r, b'' if is_binary else u'')

    /*else*/ {
      if (__pyx_v_is_binary) {
        __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_b__7);
        __pyx_t_2 = __pyx_mstate_global->__pyx_kp_b__7;
      } else {
        __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__7);
        __pyx_t_2 = __pyx_mstate_global->__pyx_kp_u__7;
      }
      __pyx_t_19 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_t_2); if (unlikely(__pyx_t_19 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1255, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __pyx_L16:;
    __pyx_L8_continue:;
  }

+1256:     return out

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_out);
  __pyx_r = ((PyObject *)__pyx_v_out);
  goto __pyx_L0;

 1257: 

 1258: 

+1259: cdef object _numpy_symbol_codes_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_symbol_codes_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  uint32_t const *__pyx_v_codes;
  uint8_t const *__pyx_v_validity;
  size_t __pyx_v_r;
  __Pyx_memviewslice __pyx_v_mv = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_out = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __PYX_XCLEAR_MEMVIEW(&__pyx_t_13, 1);
  __Pyx_AddTraceback("questdb._client._numpy_symbol_codes_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __PYX_XCLEAR_MEMVIEW(&__pyx_v_mv, 1);
  __Pyx_XDECREF(__pyx_v_out);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1260:         const qwp_reader_batch* batch,

 1261:         size_t col_idx,

 1262:         size_t row_count,

 1263:         object np):

 1264:     cdef qwp_reader_column_data cd

+1265:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1266:     cdef const uint32_t* codes

 1267:     cdef const uint8_t* validity

 1268:     cdef size_t r

 1269:     cdef int64_t[::1] mv

+1270:     _reader_check(

  __pyx_t_1 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 1270, __pyx_L1_error)

 1271:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1272:         'qwp_reader_batch_column_data')

+1273:     out = np.empty(row_count, dtype=np.int64)

  __pyx_t_3 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1273, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_int64); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1273, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4};
    __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1273, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1273, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1273, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_out = __pyx_t_2;
  __pyx_t_2 = 0;

+1274:     if row_count == 0:

  __pyx_t_8 = (__pyx_v_row_count == 0);
  if (__pyx_t_8) {
/* … */
  }

+1275:         return out

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_out);
    __pyx_r = __pyx_v_out;
    goto __pyx_L0;

+1276:     if cd.symbol_codes == NULL:

  __pyx_t_8 = (__pyx_v_cd.symbol_codes == NULL);
  if (unlikely(__pyx_t_8)) {
/* … */
  }

+1277:         raise QuestDBError(

    __pyx_t_7 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1277, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);

+1278:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1278, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1278, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1279:             'symbol column has {} rows but no codes buffer'.format(row_count))

    __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u_symbol_column_has_rows_but_no_co;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1279, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_10};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1279, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_7);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_3, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1277, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1277, __pyx_L1_error)

+1280:     codes = cd.symbol_codes

  __pyx_t_11 = __pyx_v_cd.symbol_codes;
  __pyx_v_codes = __pyx_t_11;

+1281:     validity = cd.validity

  __pyx_t_12 = __pyx_v_cd.validity;
  __pyx_v_validity = __pyx_t_12;

+1282:     mv = out

  __pyx_t_13 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn_int64_t(__pyx_v_out, PyBUF_WRITABLE); if (unlikely(!__pyx_t_13.memview)) __PYX_ERR(2, 1282, __pyx_L1_error)
  __pyx_v_mv = __pyx_t_13;
  __pyx_t_13.memview = NULL;
  __pyx_t_13.data = NULL;

+1283:     for r in range(row_count):

  __pyx_t_6 = __pyx_v_row_count;
  __pyx_t_14 = __pyx_t_6;
  for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
    __pyx_v_r = __pyx_t_15;

+1284:         if validity != NULL and ((validity[r >> 3] >> (r & 7)) & 1):

    __pyx_t_16 = (__pyx_v_validity != NULL);
    if (__pyx_t_16) {
    } else {
      __pyx_t_8 = __pyx_t_16;
      goto __pyx_L8_bool_binop_done;
    }
    __pyx_t_16 = ((((__pyx_v_validity[(__pyx_v_r >> 3)]) >> (__pyx_v_r & 7)) & 1) != 0);
    __pyx_t_8 = __pyx_t_16;
    __pyx_L8_bool_binop_done:;
    if (__pyx_t_8) {
/* … */
      goto __pyx_L7;
    }

+1285:             mv[r] = -1

      __pyx_t_17 = __pyx_v_r;
      __pyx_t_1 = -1;
      if (unlikely(__pyx_t_17 >= (size_t)__pyx_v_mv.shape[0])) __pyx_t_1 = 0;
      if (unlikely(__pyx_t_1 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_1);
        __PYX_ERR(2, 1285, __pyx_L1_error)
      }
      *((int64_t *) ( /* dim=0 */ ((char *) (((int64_t *) __pyx_v_mv.data) + __pyx_t_17)) )) = -1L;

 1286:         else:

+1287:             mv[r] = <int64_t>codes[r]

    /*else*/ {
      __pyx_t_17 = __pyx_v_r;
      __pyx_t_1 = -1;
      if (unlikely(__pyx_t_17 >= (size_t)__pyx_v_mv.shape[0])) __pyx_t_1 = 0;
      if (unlikely(__pyx_t_1 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_1);
        __PYX_ERR(2, 1287, __pyx_L1_error)
      }
      *((int64_t *) ( /* dim=0 */ ((char *) (((int64_t *) __pyx_v_mv.data) + __pyx_t_17)) )) = ((int64_t)(__pyx_v_codes[__pyx_v_r]));
    }
    __pyx_L7:;
  }

+1288:     return out

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_out);
  __pyx_r = __pyx_v_out;
  goto __pyx_L0;

 1289: 

 1290: 

+1291: cdef void _symbol_categories_extend(

static void __pyx_f_7questdb_7_client__symbol_categories_extend(PyObject *__pyx_v_cats, struct qwp_reader_symbol_dict const *__pyx_v_sd, size_t __pyx_v_start) {
  size_t __pyx_v_i;
  struct qwp_reader_symbol_entry const *__pyx_v_e;
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("questdb._client._symbol_categories_extend", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
}

 1292:         list cats, const qwp_reader_symbol_dict* sd, size_t start):

 1293:     cdef size_t i

 1294:     cdef const qwp_reader_symbol_entry* e

+1295:     for i in range(start, sd.entry_count):

  __pyx_t_1 = __pyx_v_sd->entry_count;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = __pyx_v_start; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

+1296:         e = &sd.entries[i]

    __pyx_v_e = (&(__pyx_v_sd->entries[__pyx_v_i]));

+1297:         if <uint64_t>e.offset + <uint64_t>e.length > <uint64_t>sd.heap_len:

    __pyx_t_4 = ((((uint64_t)__pyx_v_e->offset) + ((uint64_t)__pyx_v_e->length)) > ((uint64_t)__pyx_v_sd->heap_len));
    if (unlikely(__pyx_t_4)) {
/* … */
    }

+1298:             raise QuestDBError(

      __pyx_t_6 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1298, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);

+1299:                 QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1299, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1299, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_10 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_7))) {
        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
        assert(__pyx_t_6);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
        __pyx_t_10 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_9, __pyx_mstate_global->__pyx_kp_u_corrupt_symbol_dictionary_heap_o};
        __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1298, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __PYX_ERR(2, 1298, __pyx_L1_error)

 1300:                 'corrupt symbol dictionary heap offsets')

+1301:         cats.append(

    if (unlikely(__pyx_v_cats == Py_None)) {
      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
      __PYX_ERR(2, 1301, __pyx_L1_error)
    }
/* … */
    __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_cats, __pyx_t_5); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1301, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  }

+1302:             PyUnicode_FromStringAndSize(

    __pyx_t_5 = PyUnicode_FromStringAndSize(((char const *)(__pyx_v_sd->heap + __pyx_v_e->offset)), ((Py_ssize_t)__pyx_v_e->length)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1302, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);

 1303:                 <const char*>(sd.heap + e.offset), <Py_ssize_t>e.length))

 1304: 

 1305: 

+1306: cdef object _numpy_geohash_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_geohash_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  PyObject *__pyx_v_dtype = 0;
  size_t __pyx_v_stride;
  size_t __pyx_v_target;
  CYTHON_UNUSED Py_ssize_t __pyx_v_nbytes;
  unsigned char *__pyx_v_src;
  PyObject *__pyx_v_raw = NULL;
  PyObject *__pyx_v_wide = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF((PyObject *)__pyx_t_12);
  __Pyx_AddTraceback("questdb._client._numpy_geohash_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_dtype);
  __Pyx_XDECREF(__pyx_v_raw);
  __Pyx_XDECREF(__pyx_v_wide);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1307:         const qwp_reader_batch* batch,

 1308:         size_t col_idx,

 1309:         size_t row_count,

 1310:         object np):

 1311:     cdef qwp_reader_column_data cd

+1312:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1313:     cdef object dtype

 1314:     cdef size_t stride

 1315:     cdef size_t target

 1316:     cdef Py_ssize_t nbytes

 1317:     cdef unsigned char* src

+1318:     _reader_check(

  __pyx_t_1 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 1318, __pyx_L1_error)

 1319:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1320:         'qwp_reader_batch_column_data')

+1321:     stride = cd.value_stride

  __pyx_t_2 = __pyx_v_cd.value_stride;
  __pyx_v_stride = __pyx_t_2;

+1322:     if stride == 1:

  __pyx_t_3 = (__pyx_v_stride == 1);
  if (__pyx_t_3) {
/* … */
    goto __pyx_L3;
  }

+1323:         dtype = np.dtype(np.uint8)

    __pyx_t_5 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint8); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1323, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1323, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_dtype = __pyx_t_4;
    __pyx_t_4 = 0;

+1324:         target = 1

    __pyx_v_target = 1;

+1325:     elif stride == 2:

  __pyx_t_3 = (__pyx_v_stride == 2);
  if (__pyx_t_3) {
/* … */
    goto __pyx_L3;
  }

+1326:         dtype = np.dtype(np.uint16)

    __pyx_t_6 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint16); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1326, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1326, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_dtype = __pyx_t_4;
    __pyx_t_4 = 0;

+1327:         target = 2

    __pyx_v_target = 2;

+1328:     elif stride == 3 or stride == 4:

  switch (__pyx_v_stride) {
    case 3:
    case 4:
    __pyx_t_3 = 1;
    break;
    default:
    __pyx_t_3 = 0;
    break;
  }
  if (__pyx_t_3) {
/* … */
    goto __pyx_L3;
  }

+1329:         dtype = np.dtype(np.uint32)

    __pyx_t_5 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1329, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_dtype = __pyx_t_4;
    __pyx_t_4 = 0;

+1330:         target = 4

    __pyx_v_target = 4;

+1331:     elif stride >= 5 and stride <= 8:

  __pyx_t_7 = (__pyx_v_stride >= 5);
  if (__pyx_t_7) {
  } else {
    __pyx_t_3 = __pyx_t_7;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_7 = (__pyx_v_stride <= 8);
  __pyx_t_3 = __pyx_t_7;
  __pyx_L4_bool_binop_done:;
  if (likely(__pyx_t_3)) {
/* … */
    goto __pyx_L3;
  }

+1332:         dtype = np.dtype(np.uint64)

    __pyx_t_6 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint64); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1332, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_dtype, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1332, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_dtype = __pyx_t_4;
    __pyx_t_4 = 0;

+1333:         target = 8

    __pyx_v_target = 8;

 1334:     else:

+1335:         raise QuestDBError(

  /*else*/ {
    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1335, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);

+1336:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1336, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1336, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+1337:             'unexpected geohash byte width {}'.format(stride))

    __pyx_t_10 = __pyx_mstate_global->__pyx_kp_u_unexpected_geohash_byte_width;
    __Pyx_INCREF(__pyx_t_10);
    __pyx_t_11 = __Pyx_PyLong_FromSize_t(__pyx_v_stride); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1337, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_11};
      __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1337, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
    }
    __pyx_t_2 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_2 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_9, __pyx_t_8};
      __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_2, (3-__pyx_t_2) | (__pyx_t_2*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1335, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __PYX_ERR(2, 1335, __pyx_L1_error)
  }
  __pyx_L3:;

+1338:     if row_count == 0:

  __pyx_t_3 = (__pyx_v_row_count == 0);
  if (__pyx_t_3) {
/* … */
  }

+1339:         return np.empty(0, dtype=dtype)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_6 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0};
      __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1339, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_v_dtype, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1339, __pyx_L1_error)
      __pyx_t_4 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1339, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

+1340:     if cd.values == NULL:

  __pyx_t_3 = (__pyx_v_cd.values == NULL);
  if (unlikely(__pyx_t_3)) {
/* … */
  }

+1341:         raise QuestDBError(

    __pyx_t_8 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1341, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);

+1342:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1342, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1342, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;

+1343:             'geohash column has {} rows but no values buffer'.format(row_count))

    __pyx_t_11 = __pyx_mstate_global->__pyx_kp_u_geohash_column_has_rows_but_no_v;
    __Pyx_INCREF(__pyx_t_11);
    __pyx_t_10 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1343, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_10};
      __pyx_t_9 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1343, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __pyx_t_2 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_8);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_2 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_5, __pyx_t_9};
      __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_2, (3-__pyx_t_2) | (__pyx_t_2*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1341, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __PYX_ERR(2, 1341, __pyx_L1_error)

+1344:     nbytes = <Py_ssize_t>(row_count * stride)

  __pyx_v_nbytes = ((Py_ssize_t)(__pyx_v_row_count * __pyx_v_stride));

+1345:     src = <unsigned char*>cd.values

  __pyx_v_src = ((unsigned char *)__pyx_v_cd.values);

+1346:     if stride == target:

  __pyx_t_3 = (__pyx_v_stride == __pyx_v_target);
  if (__pyx_t_3) {
/* … */
  }

+1347:         return np.frombuffer((<unsigned char[:nbytes]>src), dtype=dtype).copy()

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = __pyx_v_np;
    __Pyx_INCREF(__pyx_t_5);
    if (!__pyx_v_src) {
      PyErr_SetString(PyExc_ValueError,"Cannot create cython.array from NULL pointer");
      __PYX_ERR(2, 1347, __pyx_L1_error)
    }
    __pyx_t_10 = __pyx_format_from_typeinfo(&__Pyx_TypeInfo_unsigned_char); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_8 = Py_BuildValue("("  __PYX_BUILD_PY_SSIZE_T  ")", ((Py_ssize_t)__pyx_v_nbytes)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    #if CYTHON_COMPILING_IN_LIMITED_API
    __pyx_t_13 = PyBytes_AsString(__pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1347, __pyx_L1_error)
    #else
    __pyx_t_13 = PyBytes_AS_STRING(__pyx_t_10);
    #endif
    __pyx_t_12 = __pyx_array_new(__pyx_t_8, sizeof(unsigned char), __pyx_t_13, "c", (char *) __pyx_v_src); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1347, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_12);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, ((PyObject *)__pyx_t_12)};
      __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1347, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_v_dtype, __pyx_t_10, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1347, __pyx_L1_error)
      __pyx_t_9 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_frombuffer, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF((PyObject *)__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1347, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __pyx_t_6 = __pyx_t_9;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_2 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_2, (1-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1347, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

+1348:     raw = np.frombuffer(

  __pyx_t_10 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_10);

+1349:         (<unsigned char[:nbytes]>src), dtype=np.uint8).reshape(

  if (!__pyx_v_src) {
    PyErr_SetString(PyExc_ValueError,"Cannot create cython.array from NULL pointer");
    __PYX_ERR(2, 1349, __pyx_L1_error)
  }
  __pyx_t_8 = __pyx_format_from_typeinfo(&__Pyx_TypeInfo_unsigned_char); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = Py_BuildValue("("  __PYX_BUILD_PY_SSIZE_T  ")", ((Py_ssize_t)__pyx_v_nbytes)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  #if CYTHON_COMPILING_IN_LIMITED_API
  __pyx_t_13 = PyBytes_AsString(__pyx_t_8); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1349, __pyx_L1_error)
  #else
  __pyx_t_13 = PyBytes_AS_STRING(__pyx_t_8);
  #endif
  __pyx_t_12 = __pyx_array_new(__pyx_t_5, sizeof(unsigned char), __pyx_t_13, "c", (char *) __pyx_v_src); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1349, __pyx_L1_error)
  __Pyx_GOTREF((PyObject *)__pyx_t_12);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_2 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_10, ((PyObject *)__pyx_t_12)};
    __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1348, __pyx_L1_error)
    __pyx_t_6 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_frombuffer, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5);
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF((PyObject *)__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_t_9 = __pyx_t_6;
  __Pyx_INCREF(__pyx_t_9);

+1350:             <Py_ssize_t>row_count, <Py_ssize_t>stride)

  __pyx_t_5 = PyLong_FromSsize_t(((Py_ssize_t)__pyx_v_row_count)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = PyLong_FromSsize_t(((Py_ssize_t)__pyx_v_stride)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_2 = 0;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_5, __pyx_t_8};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_reshape, __pyx_callargs+__pyx_t_2, (3-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1349, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_v_raw = __pyx_t_4;
  __pyx_t_4 = 0;

+1351:     wide = np.zeros((<Py_ssize_t>row_count, <Py_ssize_t>target), dtype=np.uint8)

  __pyx_t_6 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_8 = PyLong_FromSsize_t(((Py_ssize_t)__pyx_v_row_count)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1351, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = PyLong_FromSsize_t(((Py_ssize_t)__pyx_v_target)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1351, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1351, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8) != (0)) __PYX_ERR(2, 1351, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_5) != (0)) __PYX_ERR(2, 1351, __pyx_L1_error);
  __pyx_t_8 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint8); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1351, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_9};
    __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1351, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1351, __pyx_L1_error)
    __pyx_t_4 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_zeros, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1351, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_v_wide = __pyx_t_4;
  __pyx_t_4 = 0;

+1352:     wide[:, :stride] = raw

  __pyx_t_4 = __Pyx_PyLong_FromSize_t(__pyx_v_stride); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_8 = PySlice_New(Py_None, __pyx_t_4, Py_None); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(2, 1352, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8) != (0)) __PYX_ERR(2, 1352, __pyx_L1_error);
  __pyx_t_8 = 0;
  if (unlikely((PyObject_SetItem(__pyx_v_wide, __pyx_t_4, __pyx_v_raw) < 0))) __PYX_ERR(2, 1352, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1353:     return wide.view(dtype).reshape(<Py_ssize_t>row_count)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_9 = __pyx_v_wide;
  __Pyx_INCREF(__pyx_t_9);
  __pyx_t_2 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_dtype};
    __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_view, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1353, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_t_8 = __pyx_t_5;
  __Pyx_INCREF(__pyx_t_8);
  __pyx_t_9 = PyLong_FromSsize_t(((Py_ssize_t)__pyx_v_row_count)); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1353, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_2 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_9};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_reshape, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1353, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 1354: 

 1355: 

+1356: cdef object _numpy_uuid_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_uuid_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  PyObject *__pyx_v__uuid = 0;
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  uint8_t const *__pyx_v_validity;
  uint8_t const *__pyx_v_values;
  size_t __pyx_v_r;
  size_t __pyx_v_stride;
  uint64_t __pyx_v_lo;
  uint64_t __pyx_v_hi;
  PyArrayObject *__pyx_v_out = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client._numpy_uuid_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v__uuid);
  __Pyx_XDECREF((PyObject *)__pyx_v_out);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1357:         const qwp_reader_batch* batch,

 1358:         size_t col_idx,

 1359:         size_t row_count,

 1360:         object np):

+1361:     cdef object _uuid = _uuid_module()

  __pyx_t_1 = __pyx_f_7questdb_7_client__uuid_module(); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v__uuid = __pyx_t_1;
  __pyx_t_1 = 0;

 1362:     cdef qwp_reader_column_data cd

+1363:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1364:     cdef const uint8_t* validity

 1365:     cdef const uint8_t* values

 1366:     cdef size_t r

 1367:     cdef size_t stride

 1368:     cdef uint64_t lo

 1369:     cdef uint64_t hi

 1370:     cdef cnp.ndarray out

+1371:     _reader_check(

  __pyx_t_2 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(2, 1371, __pyx_L1_error)

 1372:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1373:         'qwp_reader_batch_column_data')

+1374:     out = np.empty(row_count, dtype=object)

  __pyx_t_3 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1374, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_builtin_object, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1374, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1374, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 1374, __pyx_L1_error)
  __pyx_v_out = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1375:     if row_count == 0:

  __pyx_t_7 = (__pyx_v_row_count == 0);
  if (__pyx_t_7) {
/* … */
  }

+1376:         return out

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF((PyObject *)__pyx_v_out);
    __pyx_r = ((PyObject *)__pyx_v_out);
    goto __pyx_L0;

+1377:     if cd.values == NULL:

  __pyx_t_7 = (__pyx_v_cd.values == NULL);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1378:         raise QuestDBError(

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1378, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+1379:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1379, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1379, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1380:             'uuid column has {} rows but no values buffer'.format(row_count))

    __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u_uuid_column_has_rows_but_no_valu;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1380, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_10};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1380, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_8, __pyx_t_3};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1378, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 1378, __pyx_L1_error)

+1381:     validity = cd.validity

  __pyx_t_11 = __pyx_v_cd.validity;
  __pyx_v_validity = __pyx_t_11;

+1382:     values = <const uint8_t*>cd.values

  __pyx_v_values = ((uint8_t const *)__pyx_v_cd.values);

+1383:     stride = cd.value_stride if cd.value_stride != 0 else 16

  __pyx_t_7 = (__pyx_v_cd.value_stride != 0);
  if (__pyx_t_7) {
    __pyx_t_5 = __pyx_v_cd.value_stride;
  } else {
    __pyx_t_5 = 16;
  }
  __pyx_v_stride = __pyx_t_5;

+1384:     for r in range(row_count):

  __pyx_t_5 = __pyx_v_row_count;
  __pyx_t_12 = __pyx_t_5;
  for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
    __pyx_v_r = __pyx_t_13;

+1385:         if validity != NULL and ((validity[r >> 3] >> (r & 7)) & 1):

    __pyx_t_14 = (__pyx_v_validity != NULL);
    if (__pyx_t_14) {
    } else {
      __pyx_t_7 = __pyx_t_14;
      goto __pyx_L8_bool_binop_done;
    }
    __pyx_t_14 = ((((__pyx_v_validity[(__pyx_v_r >> 3)]) >> (__pyx_v_r & 7)) & 1) != 0);
    __pyx_t_7 = __pyx_t_14;
    __pyx_L8_bool_binop_done:;
    if (__pyx_t_7) {
/* … */
    }

+1386:             continue

      goto __pyx_L5_continue;

+1387:         memcpy(&lo, values + r * stride, 8)

    (void)(memcpy((&__pyx_v_lo), (__pyx_v_values + (__pyx_v_r * __pyx_v_stride)), 8));

+1388:         memcpy(&hi, values + r * stride + 8, 8)

    (void)(memcpy((&__pyx_v_hi), ((__pyx_v_values + (__pyx_v_r * __pyx_v_stride)) + 8), 8));

+1389:         _obj_chunk_set(out, r, _uuid.UUID(int=((<object>hi) << 64) | (<object>lo)))

    __pyx_t_4 = __pyx_v__uuid;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyLong_From_uint64_t(__pyx_v_hi); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = PyNumber_Lshift(__pyx_t_3, __pyx_mstate_global->__pyx_int_64); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyLong_From_uint64_t(__pyx_v_lo); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = PyNumber_Or(__pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_15 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, NULL};
      __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_int, __pyx_t_6, __pyx_t_3, __pyx_callargs+1, 0) < (0)) __PYX_ERR(2, 1389, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_UUID, __pyx_callargs+__pyx_t_15, (1-__pyx_t_15) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_16 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_t_1); if (unlikely(__pyx_t_16 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1389, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_L5_continue:;
  }

+1390:     return out

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_out);
  __pyx_r = ((PyObject *)__pyx_v_out);
  goto __pyx_L0;

 1391: 

 1392: 

+1393: cdef object _numpy_long256_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_long256_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  uint8_t const *__pyx_v_validity;
  uint8_t const *__pyx_v_values;
  size_t __pyx_v_r;
  size_t __pyx_v_stride;
  PyArrayObject *__pyx_v_out = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client._numpy_long256_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_out);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1394:         const qwp_reader_batch* batch,

 1395:         size_t col_idx,

 1396:         size_t row_count,

 1397:         object np):

 1398:     cdef qwp_reader_column_data cd

+1399:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1400:     cdef const uint8_t* validity

 1401:     cdef const uint8_t* values

 1402:     cdef size_t r

 1403:     cdef size_t stride

 1404:     cdef cnp.ndarray out

+1405:     _reader_check(

  __pyx_t_1 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 1405, __pyx_L1_error)

 1406:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1407:         'qwp_reader_batch_column_data')

+1408:     out = np.empty(row_count, dtype=object)

  __pyx_t_3 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1408, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_builtin_object, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1408, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1408, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 1408, __pyx_L1_error)
  __pyx_v_out = ((PyArrayObject *)__pyx_t_2);
  __pyx_t_2 = 0;

+1409:     if row_count == 0:

  __pyx_t_7 = (__pyx_v_row_count == 0);
  if (__pyx_t_7) {
/* … */
  }

+1410:         return out

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF((PyObject *)__pyx_v_out);
    __pyx_r = ((PyObject *)__pyx_v_out);
    goto __pyx_L0;

+1411:     if cd.values == NULL:

  __pyx_t_7 = (__pyx_v_cd.values == NULL);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1412:         raise QuestDBError(

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+1413:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1414:             'long256 column has {} rows but no values buffer'.format(row_count))

    __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u_long256_column_has_rows_but_no_v;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1414, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_10};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1414, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_8, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1412, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1412, __pyx_L1_error)

+1415:     validity = cd.validity

  __pyx_t_11 = __pyx_v_cd.validity;
  __pyx_v_validity = __pyx_t_11;

+1416:     values = <const uint8_t*>cd.values

  __pyx_v_values = ((uint8_t const *)__pyx_v_cd.values);

+1417:     stride = cd.value_stride if cd.value_stride != 0 else 32

  __pyx_t_7 = (__pyx_v_cd.value_stride != 0);
  if (__pyx_t_7) {
    __pyx_t_5 = __pyx_v_cd.value_stride;
  } else {
    __pyx_t_5 = 32;
  }
  __pyx_v_stride = __pyx_t_5;

+1418:     for r in range(row_count):

  __pyx_t_5 = __pyx_v_row_count;
  __pyx_t_12 = __pyx_t_5;
  for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
    __pyx_v_r = __pyx_t_13;

+1419:         if validity != NULL and ((validity[r >> 3] >> (r & 7)) & 1):

    __pyx_t_14 = (__pyx_v_validity != NULL);
    if (__pyx_t_14) {
    } else {
      __pyx_t_7 = __pyx_t_14;
      goto __pyx_L8_bool_binop_done;
    }
    __pyx_t_14 = ((((__pyx_v_validity[(__pyx_v_r >> 3)]) >> (__pyx_v_r & 7)) & 1) != 0);
    __pyx_t_7 = __pyx_t_14;
    __pyx_L8_bool_binop_done:;
    if (__pyx_t_7) {
/* … */
    }

+1420:             continue

      goto __pyx_L5_continue;

+1421:         _obj_chunk_set(out, r, int.from_bytes(

    __pyx_t_4 = ((PyObject *)(&PyLong_Type));
    __Pyx_INCREF(__pyx_t_4);
/* … */
    __pyx_t_16 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_t_2); if (unlikely(__pyx_t_16 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1421, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_L5_continue:;
  }

+1422:             PyBytes_FromStringAndSize(<const char*>(values + r * stride), 32),

    __pyx_t_3 = PyBytes_FromStringAndSize(((char const *)(__pyx_v_values + (__pyx_v_r * __pyx_v_stride))), 32); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1422, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);

+1423:             'little', signed=False))

    __pyx_t_15 = 0;
    {
      PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_little};
      __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1421, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_signed, Py_False, __pyx_t_8, __pyx_callargs+3, 0) < (0)) __PYX_ERR(2, 1421, __pyx_L1_error)
      __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_from_bytes, __pyx_callargs+__pyx_t_15, (3-__pyx_t_15) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1421, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }

+1424:     return out

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_out);
  __pyx_r = ((PyObject *)__pyx_v_out);
  goto __pyx_L0;

 1425: 

 1426: 

+1427: cdef object _numpy_decimal_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_decimal_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  PyObject *__pyx_v_Decimal = 0;
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  uint8_t const *__pyx_v_validity;
  uint8_t const *__pyx_v_values;
  size_t __pyx_v_r;
  size_t __pyx_v_width;
  int __pyx_v_scale;
  PyArrayObject *__pyx_v_out = 0;
  PyObject *__pyx_v_unscaled = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client._numpy_decimal_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_Decimal);
  __Pyx_XDECREF((PyObject *)__pyx_v_out);
  __Pyx_XDECREF(__pyx_v_unscaled);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_7questdb_7_client_18_numpy_array_chunk_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */

 1428:         const qwp_reader_batch* batch,

 1429:         size_t col_idx,

 1430:         size_t row_count,

 1431:         object np):

+1432:     cdef object Decimal = _decimal_type()

  __pyx_t_1 = __pyx_f_7questdb_7_client__decimal_type(); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1432, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Decimal = __pyx_t_1;
  __pyx_t_1 = 0;

 1433:     cdef qwp_reader_column_data cd

+1434:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1435:     cdef const uint8_t* validity

 1436:     cdef const uint8_t* values

 1437:     cdef size_t r

 1438:     cdef size_t width

 1439:     cdef int scale

 1440:     cdef cnp.ndarray out

+1441:     _reader_check(

  __pyx_t_2 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(2, 1441, __pyx_L1_error)

 1442:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1443:         'qwp_reader_batch_column_data')

+1444:     out = np.empty(row_count, dtype=object)

  __pyx_t_3 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1444, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_builtin_object, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1444, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1444, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 1444, __pyx_L1_error)
  __pyx_v_out = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1445:     if row_count == 0:

  __pyx_t_7 = (__pyx_v_row_count == 0);
  if (__pyx_t_7) {
/* … */
  }

+1446:         return out

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF((PyObject *)__pyx_v_out);
    __pyx_r = ((PyObject *)__pyx_v_out);
    goto __pyx_L0;

+1447:     if cd.values == NULL:

  __pyx_t_7 = (__pyx_v_cd.values == NULL);
  if (unlikely(__pyx_t_7)) {
/* … */
  }

+1448:         raise QuestDBError(

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1448, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+1449:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1450:             'decimal column has {} rows but no values buffer'.format(row_count))

    __pyx_t_9 = __pyx_mstate_global->__pyx_kp_u_decimal_column_has_rows_but_no_v;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1450, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_10};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1450, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_8, __pyx_t_3};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1448, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 1448, __pyx_L1_error)

+1451:     validity = cd.validity

  __pyx_t_11 = __pyx_v_cd.validity;
  __pyx_v_validity = __pyx_t_11;

+1452:     values = <const uint8_t*>cd.values

  __pyx_v_values = ((uint8_t const *)__pyx_v_cd.values);

+1453:     width = cd.value_stride

  __pyx_t_5 = __pyx_v_cd.value_stride;
  __pyx_v_width = __pyx_t_5;

+1454:     scale = cd.decimal_scale

  __pyx_t_12 = __pyx_v_cd.decimal_scale;
  __pyx_v_scale = __pyx_t_12;

+1455:     for r in range(row_count):

  __pyx_t_5 = __pyx_v_row_count;
  __pyx_t_13 = __pyx_t_5;
  for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
    __pyx_v_r = __pyx_t_14;

+1456:         if validity != NULL and ((validity[r >> 3] >> (r & 7)) & 1):

    __pyx_t_15 = (__pyx_v_validity != NULL);
    if (__pyx_t_15) {
    } else {
      __pyx_t_7 = __pyx_t_15;
      goto __pyx_L8_bool_binop_done;
    }
    __pyx_t_15 = ((((__pyx_v_validity[(__pyx_v_r >> 3)]) >> (__pyx_v_r & 7)) & 1) != 0);
    __pyx_t_7 = __pyx_t_15;
    __pyx_L8_bool_binop_done:;
    if (__pyx_t_7) {
/* … */
    }

+1457:             continue

      goto __pyx_L5_continue;

+1458:         unscaled = int.from_bytes(

    __pyx_t_4 = ((PyObject *)(&PyLong_Type));
    __Pyx_INCREF(__pyx_t_4);

+1459:             PyBytes_FromStringAndSize(

    __pyx_t_3 = PyBytes_FromStringAndSize(((char const *)(__pyx_v_values + (__pyx_v_r * __pyx_v_width))), ((Py_ssize_t)__pyx_v_width)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1459, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);

 1460:                 <const char*>(values + r * width), <Py_ssize_t>width),

+1461:             'little', signed=True)

    __pyx_t_16 = 0;
    {
      PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_little};
      __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1458, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_signed, Py_True, __pyx_t_8, __pyx_callargs+3, 0) < (0)) __PYX_ERR(2, 1458, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_from_bytes, __pyx_callargs+__pyx_t_16, (3-__pyx_t_16) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1458, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_XDECREF_SET(__pyx_v_unscaled, __pyx_t_1);
    __pyx_t_1 = 0;

+1462:         _obj_chunk_set(out, r, Decimal(f'{unscaled}e{-scale}'))

    __pyx_t_8 = NULL;
    __Pyx_INCREF(__pyx_v_Decimal);
    __pyx_t_3 = __pyx_v_Decimal; 
    __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_unscaled, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1462, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = __Pyx_PyUnicode_From_int((-__pyx_v_scale), 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1462, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_17[0] = __pyx_t_4;
    __pyx_t_17[1] = __pyx_mstate_global->__pyx_n_u_e;
    __pyx_t_17[2] = __pyx_t_6;
    __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_17, 3, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 1 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4));
    if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1462, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_16 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_8);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_16 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_10};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_16, (2-__pyx_t_16) | (__pyx_t_16*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1462, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_18 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_t_1); if (unlikely(__pyx_t_18 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1462, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_L5_continue:;
  }

+1463:     return out

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_out);
  __pyx_r = ((PyObject *)__pyx_v_out);
  goto __pyx_L0;

 1464: 

 1465: 

+1466: cdef object _numpy_array_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_array_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, enum qwp_reader_column_kind __pyx_v_kind, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk *__pyx_cur_scope;
  struct qwp_reader_array_data __pyx_v_ad;
  questdb_error *__pyx_v_err;
  uint8_t const *__pyx_v_validity;
  uint8_t const *__pyx_v_data;
  uint32_t const *__pyx_v_data_offsets;
  uint32_t const *__pyx_v_shape_offsets;
  size_t __pyx_v_r;
  uint32_t __pyx_v_dstart;
  uint32_t __pyx_v_dend;
  Py_ssize_t __pyx_v_blen;
  PyArrayObject *__pyx_v_out = 0;
  PyObject *__pyx_v_flat = NULL;
  PyObject *__pyx_gb_7questdb_7_client_18_numpy_array_chunk_2generator3 = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 1466, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF((PyObject *)__pyx_t_21);
  __Pyx_AddTraceback("questdb._client._numpy_array_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_out);
  __Pyx_XDECREF(__pyx_v_flat);
  __Pyx_XDECREF(__pyx_gb_7questdb_7_client_18_numpy_array_chunk_2generator3);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk {
  PyObject_HEAD
  uint32_t __pyx_v_send;
  uint32_t const *__pyx_v_shapes;
  uint32_t __pyx_v_sstart;
};

 1467:         const qwp_reader_batch* batch,

 1468:         size_t col_idx,

 1469:         qwp_reader_column_kind kind,

 1470:         size_t row_count,

 1471:         object np):

 1472:     cdef qwp_reader_array_data ad

+1473:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1474:     cdef const uint8_t* validity

 1475:     cdef const uint8_t* data

 1476:     cdef const uint32_t* data_offsets

 1477:     cdef const uint32_t* shapes

 1478:     cdef const uint32_t* shape_offsets

 1479:     cdef size_t r

 1480:     cdef size_t k

 1481:     cdef uint32_t dstart

 1482:     cdef uint32_t dend

 1483:     cdef uint32_t sstart

 1484:     cdef uint32_t send

 1485:     cdef Py_ssize_t blen

 1486:     cdef cnp.ndarray out

+1487:     if kind != qwp_reader_column_kind_double_array:

  __pyx_t_1 = (__pyx_v_kind != qwp_reader_column_kind_double_array);
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+1488:         raise QuestDBError(

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1488, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+1489:             QuestDBErrorCode.InvalidApiCall,

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1489, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1489, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1490:             'numpy egress supports only double arrays (kind 0x{:02X})'.format(

    __pyx_t_7 = __pyx_mstate_global->__pyx_kp_u_numpy_egress_supports_only_doubl;
    __Pyx_INCREF(__pyx_t_7);

+1491:                 <int>kind))

    __pyx_t_8 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1491, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1490, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_6, __pyx_t_5};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1488, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1488, __pyx_L1_error)

+1492:     _reader_check(

  __pyx_t_10 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_array_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_ad), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_array_column_da); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 1492, __pyx_L1_error)

 1493:         qwp_reader_batch_array_column_data(batch, col_idx, &ad, &err), &err,

 1494:         'qwp_reader_batch_array_column_data')

+1495:     out = np.empty(row_count, dtype=object)

  __pyx_t_4 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1495, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_5};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1495, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_builtin_object, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1495, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1495, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 1495, __pyx_L1_error)
  __pyx_v_out = ((PyArrayObject *)__pyx_t_2);
  __pyx_t_2 = 0;

+1496:     if row_count == 0:

  __pyx_t_1 = (__pyx_v_row_count == 0);
  if (__pyx_t_1) {
/* … */
  }

+1497:         return out

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF((PyObject *)__pyx_v_out);
    __pyx_r = ((PyObject *)__pyx_v_out);
    goto __pyx_L0;

+1498:     if ad.data_offsets == NULL or ad.shape_offsets == NULL:

  __pyx_t_11 = (__pyx_v_ad.data_offsets == NULL);
  if (!__pyx_t_11) {
  } else {
    __pyx_t_1 = __pyx_t_11;
    goto __pyx_L6_bool_binop_done;
  }
  __pyx_t_11 = (__pyx_v_ad.shape_offsets == NULL);
  __pyx_t_1 = __pyx_t_11;
  __pyx_L6_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+1499:         raise QuestDBError(

    __pyx_t_6 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1499, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);

+1500:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1500, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1500, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1501:             'array column has {} rows but no offset tables'.format(row_count))

    __pyx_t_8 = __pyx_mstate_global->__pyx_kp_u_array_column_has_rows_but_no_off;
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_7 = __Pyx_PyLong_FromSize_t(__pyx_v_row_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1501, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_7};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1501, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_6);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_4};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1499, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1499, __pyx_L1_error)

+1502:     if ad.data == NULL and ad.data_len > 0:

  __pyx_t_11 = (__pyx_v_ad.data == NULL);
  if (__pyx_t_11) {
  } else {
    __pyx_t_1 = __pyx_t_11;
    goto __pyx_L9_bool_binop_done;
  }
  __pyx_t_11 = (__pyx_v_ad.data_len > 0);
  __pyx_t_1 = __pyx_t_11;
  __pyx_L9_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+1503:         raise QuestDBError(

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1503, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+1504:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1504, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1504, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+1505:             'array column has {} data bytes but no data buffer'.format(

    __pyx_t_7 = __pyx_mstate_global->__pyx_kp_u_array_column_has_data_bytes_but;
    __Pyx_INCREF(__pyx_t_7);

+1506:                 ad.data_len))

    __pyx_t_8 = __Pyx_PyLong_FromSize_t(__pyx_v_ad.data_len); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1506, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1505, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1503, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1503, __pyx_L1_error)

+1507:     if ad.shapes == NULL and ad.shapes_len > 0:

  __pyx_t_11 = (__pyx_v_ad.shapes == NULL);
  if (__pyx_t_11) {
  } else {
    __pyx_t_1 = __pyx_t_11;
    goto __pyx_L12_bool_binop_done;
  }
  __pyx_t_11 = (__pyx_v_ad.shapes_len > 0);
  __pyx_t_1 = __pyx_t_11;
  __pyx_L12_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+1508:         raise QuestDBError(

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1508, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);

+1509:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1509, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1509, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+1510:             'array column has {} shape entries but no shapes buffer'.format(

    __pyx_t_8 = __pyx_mstate_global->__pyx_kp_u_array_column_has_shape_entries_b;
    __Pyx_INCREF(__pyx_t_8);

+1511:                 ad.shapes_len))

    __pyx_t_7 = __Pyx_PyLong_FromSize_t(__pyx_v_ad.shapes_len); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1511, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_7};
      __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1510, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_t_6};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1508, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 1508, __pyx_L1_error)

+1512:     validity = ad.validity

  __pyx_t_12 = __pyx_v_ad.validity;
  __pyx_v_validity = __pyx_t_12;

+1513:     data = ad.data

  __pyx_t_13 = __pyx_v_ad.data;
  __pyx_v_data = __pyx_t_13;

+1514:     data_offsets = ad.data_offsets

  __pyx_t_14 = __pyx_v_ad.data_offsets;
  __pyx_v_data_offsets = __pyx_t_14;

+1515:     shapes = ad.shapes

  __pyx_t_15 = __pyx_v_ad.shapes;
  __pyx_cur_scope->__pyx_v_shapes = __pyx_t_15;

+1516:     shape_offsets = ad.shape_offsets

  __pyx_t_16 = __pyx_v_ad.shape_offsets;
  __pyx_v_shape_offsets = __pyx_t_16;

+1517:     for r in range(row_count):

  __pyx_t_9 = __pyx_v_row_count;
  __pyx_t_17 = __pyx_t_9;
  for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
    __pyx_v_r = __pyx_t_18;

+1518:         if validity != NULL and ((validity[r >> 3] >> (r & 7)) & 1):

    __pyx_t_11 = (__pyx_v_validity != NULL);
    if (__pyx_t_11) {
    } else {
      __pyx_t_1 = __pyx_t_11;
      goto __pyx_L17_bool_binop_done;
    }
    __pyx_t_11 = ((((__pyx_v_validity[(__pyx_v_r >> 3)]) >> (__pyx_v_r & 7)) & 1) != 0);
    __pyx_t_1 = __pyx_t_11;
    __pyx_L17_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+1519:             continue

      goto __pyx_L14_continue;

+1520:         dstart = data_offsets[r]

    __pyx_v_dstart = (__pyx_v_data_offsets[__pyx_v_r]);

+1521:         dend = data_offsets[r + 1]

    __pyx_v_dend = (__pyx_v_data_offsets[(__pyx_v_r + 1)]);

+1522:         if dend < dstart or <uint64_t>dend > <uint64_t>ad.data_len:

    __pyx_t_11 = (__pyx_v_dend < __pyx_v_dstart);
    if (!__pyx_t_11) {
    } else {
      __pyx_t_1 = __pyx_t_11;
      goto __pyx_L20_bool_binop_done;
    }
    __pyx_t_11 = (((uint64_t)__pyx_v_dend) > ((uint64_t)__pyx_v_ad.data_len));
    __pyx_t_1 = __pyx_t_11;
    __pyx_L20_bool_binop_done:;
    if (unlikely(__pyx_t_1)) {
/* … */
    }

+1523:             raise QuestDBError(

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1523, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);

+1524:                 QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1524, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1524, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1525:                 'corrupt array data offsets in column kind 0x{:02X}'.format(

      __pyx_t_7 = __pyx_mstate_global->__pyx_kp_u_corrupt_array_data_offsets_in_co;
      __Pyx_INCREF(__pyx_t_7);

+1526:                     <int>kind))

      __pyx_t_8 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1526, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_19 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_8};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_19, (2-__pyx_t_19) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1525, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __pyx_t_19 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_19 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_4, __pyx_t_5};
        __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_19, (3-__pyx_t_19) | (__pyx_t_19*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1523, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_Raise(__pyx_t_2, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __PYX_ERR(2, 1523, __pyx_L1_error)

+1527:         blen = <Py_ssize_t>(dend - dstart)

    __pyx_v_blen = ((Py_ssize_t)(__pyx_v_dend - __pyx_v_dstart));

+1528:         if blen > 0:

    __pyx_t_1 = (__pyx_v_blen > 0);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L22;
    }

+1529:             flat = np.frombuffer(

      __pyx_t_4 = __pyx_v_np;
      __Pyx_INCREF(__pyx_t_4);

+1530:                 (<unsigned char[:blen]>(<unsigned char*>(data + dstart))),

      __pyx_t_20 = ((unsigned char *)(__pyx_v_data + __pyx_v_dstart));
      if (!__pyx_t_20) {
        PyErr_SetString(PyExc_ValueError,"Cannot create cython.array from NULL pointer");
        __PYX_ERR(2, 1530, __pyx_L1_error)
      }
      __pyx_t_8 = __pyx_format_from_typeinfo(&__Pyx_TypeInfo_unsigned_char); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1530, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_3 = Py_BuildValue("("  __PYX_BUILD_PY_SSIZE_T  ")", ((Py_ssize_t)__pyx_v_blen)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1530, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      #if CYTHON_COMPILING_IN_LIMITED_API
      __pyx_t_22 = PyBytes_AsString(__pyx_t_8); if (unlikely(!__pyx_t_22)) __PYX_ERR(2, 1530, __pyx_L1_error)
      #else
      __pyx_t_22 = PyBytes_AS_STRING(__pyx_t_8);
      #endif
      __pyx_t_21 = __pyx_array_new(__pyx_t_3, sizeof(unsigned char), __pyx_t_22, "c", (char *) __pyx_t_20); if (unlikely(!__pyx_t_21)) __PYX_ERR(2, 1530, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_21);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+1531:                 dtype=np.float64).copy()

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_float64); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1531, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_19 = 0;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, ((PyObject *)__pyx_t_21)};
        __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1529, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1529, __pyx_L1_error)
        __pyx_t_5 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_frombuffer, __pyx_callargs+__pyx_t_19, (2-__pyx_t_19) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3);
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF((PyObject *)__pyx_t_21); __pyx_t_21 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1529, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __pyx_t_6 = __pyx_t_5;
      __Pyx_INCREF(__pyx_t_6);
      __pyx_t_19 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_19, (1-__pyx_t_19) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1531, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_XDECREF_SET(__pyx_v_flat, __pyx_t_2);
      __pyx_t_2 = 0;

 1532:         else:

+1533:             flat = np.empty(0, dtype=np.float64)

    /*else*/ {
      __pyx_t_5 = __pyx_v_np;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_float64); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1533, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_19 = 0;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0};
        __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1533, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1533, __pyx_L1_error)
        __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_empty, __pyx_callargs+__pyx_t_19, (2-__pyx_t_19) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3);
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1533, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_XDECREF_SET(__pyx_v_flat, __pyx_t_2);
      __pyx_t_2 = 0;
    }
    __pyx_L22:;

+1534:         sstart = shape_offsets[r]

    __pyx_cur_scope->__pyx_v_sstart = (__pyx_v_shape_offsets[__pyx_v_r]);

+1535:         send = shape_offsets[r + 1]

    __pyx_cur_scope->__pyx_v_send = (__pyx_v_shape_offsets[(__pyx_v_r + 1)]);

+1536:         if send < sstart or <uint64_t>send > <uint64_t>ad.shapes_len:

    __pyx_t_11 = (__pyx_cur_scope->__pyx_v_send < __pyx_cur_scope->__pyx_v_sstart);
    if (!__pyx_t_11) {
    } else {
      __pyx_t_1 = __pyx_t_11;
      goto __pyx_L24_bool_binop_done;
    }
    __pyx_t_11 = (((uint64_t)__pyx_cur_scope->__pyx_v_send) > ((uint64_t)__pyx_v_ad.shapes_len));
    __pyx_t_1 = __pyx_t_11;
    __pyx_L24_bool_binop_done:;
    if (unlikely(__pyx_t_1)) {
/* … */
    }

+1537:             raise QuestDBError(

      __pyx_t_3 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1537, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);

+1538:                 QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1538, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1538, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1539:                 'corrupt array shape offsets in column kind 0x{:02X}'.format(

      __pyx_t_4 = __pyx_mstate_global->__pyx_kp_u_corrupt_array_shape_offsets_in_c;
      __Pyx_INCREF(__pyx_t_4);

+1540:                     <int>kind))

      __pyx_t_7 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1540, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_19 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
        __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_19, (2-__pyx_t_19) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1539, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __pyx_t_19 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_6))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
        assert(__pyx_t_3);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
        __pyx_t_19 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_8, __pyx_t_5};
        __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_19, (3-__pyx_t_19) | (__pyx_t_19*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1537, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_Raise(__pyx_t_2, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __PYX_ERR(2, 1537, __pyx_L1_error)

+1541:         if send > sstart:

    __pyx_t_1 = (__pyx_cur_scope->__pyx_v_send > __pyx_cur_scope->__pyx_v_sstart);
    if (__pyx_t_1) {
/* … */
      goto __pyx_L26;
    }

+1542:             _obj_chunk_set(out, r, flat.reshape(

      __pyx_t_6 = __pyx_v_flat;
      __Pyx_INCREF(__pyx_t_6);
/* … */
      __pyx_t_23 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_t_2); if (unlikely(__pyx_t_23 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1542, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1543:                 tuple(shapes[sstart + k] for k in range(send - sstart))))

static PyObject *__pyx_pf_7questdb_7_client_18_numpy_array_chunk_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_3_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_3_genexpr *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct_3_genexpr(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct_3_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct_3_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 1543, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk *) __pyx_self;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7questdb_7_client_18_numpy_array_chunk_2generator3, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_numpy_array_chunk_locals_genexp, __pyx_mstate_global->__pyx_n_u_questdb__client); if (unlikely(!gen)) __PYX_ERR(2, 1543, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("questdb._client._numpy_array_chunk.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_7questdb_7_client_18_numpy_array_chunk_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(2, 1543, __pyx_L1_error)
  }
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(2, 1543, __pyx_L1_error) }
  __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1543, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1543, __pyx_L1_error)
  for (;;) {
    {
      __pyx_t_3 = __pyx_t_2(__pyx_t_1);
      if (unlikely(!__pyx_t_3)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 1543, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_k);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_k, __pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_3);
    __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyLong_From_uint32_t(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_sstart); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_cur_scope->__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_4); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1543, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyLong_From_uint32_t((__pyx_cur_scope->__pyx_outer_scope->__pyx_v_shapes[__pyx_t_5])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    __Pyx_XGIVEREF(__pyx_t_1);
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
    __pyx_cur_scope->__pyx_t_1 = __pyx_t_2;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L6_resume_from_yield:;
    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
    __pyx_cur_scope->__pyx_t_0 = 0;
    __Pyx_XGOTREF(__pyx_t_1);
    __pyx_t_2 = __pyx_cur_scope->__pyx_t_1;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 1543, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
      __pyx_t_8 = NULL;
      __pyx_t_3 = __Pyx_PyLong_From_uint32_t((__pyx_cur_scope->__pyx_v_send - __pyx_cur_scope->__pyx_v_sstart)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1543, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_19 = 1;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3};
        __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_19, (2-__pyx_t_19) | (__pyx_t_19*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1543, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __pyx_t_3 = __pyx_pf_7questdb_7_client_18_numpy_array_chunk_genexpr(((PyObject*)__pyx_cur_scope), __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1543, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1543, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_19 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_reshape, __pyx_callargs+__pyx_t_19, (2-__pyx_t_19) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1542, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct_3_genexpr {
  PyObject_HEAD
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_2___pyx_f_7questdb_7_client__numpy_array_chunk *__pyx_outer_scope;
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_k;
  PyObject *__pyx_t_0;
  PyObject *(*__pyx_t_1)(PyObject *);
};

 1544:         else:

+1545:             _obj_chunk_set(out, r, flat)

    /*else*/ {
      __pyx_t_23 = __pyx_f_7questdb_7_client__obj_chunk_set(__pyx_v_out, __pyx_v_r, __pyx_v_flat); if (unlikely(__pyx_t_23 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 1545, __pyx_L1_error)
    }
    __pyx_L26:;
    __pyx_L14_continue:;
  }

+1546:     return out

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_out);
  __pyx_r = ((PyObject *)__pyx_v_out);
  goto __pyx_L0;

 1547: 

 1548: 

+1549: cdef object _numpy_column_chunk(

static PyObject *__pyx_f_7questdb_7_client__numpy_column_chunk(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, enum qwp_reader_column_kind __pyx_v_kind, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("questdb._client._numpy_column_chunk", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1550:         const qwp_reader_batch* batch,

 1551:         size_t col_idx,

 1552:         qwp_reader_column_kind kind,

 1553:         size_t row_count,

 1554:         object np):

+1555:     if kind == qwp_reader_column_kind_symbol:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_symbol);
  if (__pyx_t_1) {
/* … */
  }

+1556:         return _numpy_symbol_codes_chunk(batch, col_idx, row_count, np)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_symbol_codes_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1556, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1557:     if (kind == qwp_reader_column_kind_varchar

  switch (__pyx_v_kind) {
    case qwp_reader_column_kind_varchar:
    case qwp_reader_column_kind_binary:
/* … */
    break;
    default: break;
  }

 1558:             or kind == qwp_reader_column_kind_binary):

+1559:         return _numpy_varlen_chunk(batch, col_idx, kind, row_count, np)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_varlen_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_kind, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1559, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1560:     if kind == qwp_reader_column_kind_geohash:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_geohash);
  if (__pyx_t_1) {
/* … */
  }

+1561:         return _numpy_geohash_chunk(batch, col_idx, row_count, np)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_geohash_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1561, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1562:     if kind == qwp_reader_column_kind_uuid:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_uuid);
  if (__pyx_t_1) {
/* … */
  }

+1563:         return _numpy_uuid_chunk(batch, col_idx, row_count, np)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_uuid_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1563, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1564:     if kind == qwp_reader_column_kind_long256:

  __pyx_t_1 = (__pyx_v_kind == qwp_reader_column_kind_long256);
  if (__pyx_t_1) {
/* … */
  }

+1565:         return _numpy_long256_chunk(batch, col_idx, row_count, np)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_long256_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1565, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1566:     if (kind == qwp_reader_column_kind_decimal64

  switch (__pyx_v_kind) {
    case qwp_reader_column_kind_decimal64:
    case qwp_reader_column_kind_decimal128:
/* … */
    break;
    default: break;
  }

+1567:             or kind == qwp_reader_column_kind_decimal128

    case qwp_reader_column_kind_decimal256:

 1568:             or kind == qwp_reader_column_kind_decimal256):

+1569:         return _numpy_decimal_chunk(batch, col_idx, row_count, np)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_decimal_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1569, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1570:     if (kind == qwp_reader_column_kind_double_array

  switch (__pyx_v_kind) {
    case qwp_reader_column_kind_double_array:
    case qwp_reader_column_kind_long_array:
/* … */
    break;
    default: break;
  }

 1571:             or kind == qwp_reader_column_kind_long_array):

+1572:         return _numpy_array_chunk(batch, col_idx, kind, row_count, np)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_array_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_kind, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1572, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1573:     return _numpy_fixed_chunk(batch, col_idx, kind, row_count, np)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_fixed_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_kind, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1573, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1574: 

 1575: 

+1576: cdef bint _is_hybrid_int(qwp_reader_column_kind kind):

static int __pyx_f_7questdb_7_client__is_hybrid_int(enum qwp_reader_column_kind __pyx_v_kind) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

+1577:     return (kind == qwp_reader_column_kind_int

    case qwp_reader_column_kind_long:

+1578:             or kind == qwp_reader_column_kind_long

  switch (__pyx_v_kind) {
    case qwp_reader_column_kind_int:
/* … */
    case qwp_reader_column_kind_ipv4:
/* … */
    __pyx_t_1 = 1;
    break;
    default:
    __pyx_t_1 = 0;
    break;
  }
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

+1579:             or kind == qwp_reader_column_kind_ipv4

    case qwp_reader_column_kind_geohash:

 1580:             or kind == qwp_reader_column_kind_geohash)

 1581: 

 1582: 

+1583: cdef object _numpy_validity_mask(

static PyObject *__pyx_f_7questdb_7_client__numpy_validity_mask(struct qwp_reader_batch const *__pyx_v_batch, size_t __pyx_v_col_idx, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  struct qwp_reader_column_data __pyx_v_cd;
  questdb_error *__pyx_v_err;
  CYTHON_UNUSED Py_ssize_t __pyx_v_vbytes;
  unsigned char *__pyx_v_vsrc;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF((PyObject *)__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("questdb._client._numpy_validity_mask", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1584:         const qwp_reader_batch* batch,

 1585:         size_t col_idx,

 1586:         size_t row_count,

 1587:         object np):

 1588:     cdef qwp_reader_column_data cd

+1589:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1590:     cdef Py_ssize_t vbytes

 1591:     cdef unsigned char* vsrc

+1592:     _reader_check(

  __pyx_t_1 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_data); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 1592, __pyx_L1_error)

 1593:         qwp_reader_batch_column_data(batch, col_idx, &cd, &err), &err,

 1594:         'qwp_reader_batch_column_data')

+1595:     if row_count == 0 or cd.validity == NULL:

  __pyx_t_3 = (__pyx_v_row_count == 0);
  if (!__pyx_t_3) {
  } else {
    __pyx_t_2 = __pyx_t_3;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = (__pyx_v_cd.validity == NULL);
  __pyx_t_2 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

+1596:         return None

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

+1597:     vbytes = <Py_ssize_t>((row_count + 7) // 8)

  __pyx_v_vbytes = ((Py_ssize_t)((__pyx_v_row_count + 7) / 8));

+1598:     vsrc = <unsigned char*>cd.validity

  __pyx_v_vsrc = ((unsigned char *)__pyx_v_cd.validity);

+1599:     return np.unpackbits(

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_7 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_7);

+1600:         np.frombuffer((<unsigned char[:vbytes]>vsrc), dtype=np.uint8),

  __pyx_t_9 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_9);
  if (!__pyx_v_vsrc) {
    PyErr_SetString(PyExc_ValueError,"Cannot create cython.array from NULL pointer");
    __PYX_ERR(2, 1600, __pyx_L1_error)
  }
  __pyx_t_12 = __pyx_format_from_typeinfo(&__Pyx_TypeInfo_unsigned_char); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_11 = Py_BuildValue("("  __PYX_BUILD_PY_SSIZE_T  ")", ((Py_ssize_t)__pyx_v_vbytes)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  #if CYTHON_COMPILING_IN_LIMITED_API
  __pyx_t_13 = PyBytes_AsString(__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1600, __pyx_L1_error)
  #else
  __pyx_t_13 = PyBytes_AS_STRING(__pyx_t_12);
  #endif
  __pyx_t_10 = __pyx_array_new(__pyx_t_11, sizeof(unsigned char), __pyx_t_13, "c", (char *) __pyx_v_vsrc); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1600, __pyx_L1_error)
  __Pyx_GOTREF((PyObject *)__pyx_t_10);
  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_np, __pyx_mstate_global->__pyx_n_u_uint8); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __pyx_t_14 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_9, ((PyObject *)__pyx_t_10)};
    __pyx_t_11 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1600, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_11, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1600, __pyx_L1_error)
    __pyx_t_8 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_frombuffer, __pyx_callargs+__pyx_t_14, (2-__pyx_t_14) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_11);
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF((PyObject *)__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1600, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
  }

+1601:         count=<Py_ssize_t>row_count, bitorder='little').astype(bool)

  __pyx_t_11 = PyLong_FromSsize_t(((Py_ssize_t)__pyx_v_row_count)); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __pyx_t_14 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_7, __pyx_t_8};
    __pyx_t_12 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1599, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_count, __pyx_t_11, __pyx_t_12, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1599, __pyx_L1_error)
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_bitorder, __pyx_mstate_global->__pyx_n_u_little, __pyx_t_12, __pyx_callargs+2, 1) < (0)) __PYX_ERR(2, 1599, __pyx_L1_error)
    __pyx_t_6 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_unpackbits, __pyx_callargs+__pyx_t_14, (2-__pyx_t_14) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_12);
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1599, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
  }
  __pyx_t_5 = __pyx_t_6;
  __Pyx_INCREF(__pyx_t_5);
  __pyx_t_14 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)__pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool)};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_14, (2-__pyx_t_14) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1601, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 1602: 

 1603: 

+1604: cdef object _build_nullable_array(

static PyObject *__pyx_f_7questdb_7_client__build_nullable_array(PyObject *__pyx_v_values, PyObject *__pyx_v_mask, enum qwp_reader_column_kind __pyx_v_kind, PyObject *__pyx_v_pd) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("questdb._client._build_nullable_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1605:         values, mask, qwp_reader_column_kind kind, object pd):

+1606:     if (kind == qwp_reader_column_kind_float

  switch (__pyx_v_kind) {
    case qwp_reader_column_kind_float:
    case qwp_reader_column_kind_double:
/* … */
    break;
    default: break;
  }

 1607:             or kind == qwp_reader_column_kind_double):

+1608:         return pd.arrays.FloatingArray(values, mask)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_pd, __pyx_mstate_global->__pyx_n_u_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1608, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __pyx_t_3;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_values, __pyx_v_mask};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_FloatingArray, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1608, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

+1609:     if kind == qwp_reader_column_kind_boolean:

  __pyx_t_5 = (__pyx_v_kind == qwp_reader_column_kind_boolean);
  if (__pyx_t_5) {
/* … */
  }

+1610:         return pd.arrays.BooleanArray(values, mask)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_pd, __pyx_mstate_global->__pyx_n_u_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1610, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __pyx_t_2;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_4 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_values, __pyx_v_mask};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_BooleanArray, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1610, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

+1611:     return pd.arrays.IntegerArray(values, mask)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_pd, __pyx_mstate_global->__pyx_n_u_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1611, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_values, __pyx_v_mask};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_IntegerArray, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1611, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1612: 

 1613: 

+1614: cdef object _combine_hybrid_mask(list value_chunks, list mask_chunks, object np):

static PyObject *__pyx_f_7questdb_7_client__combine_hybrid_mask(PyObject *__pyx_v_value_chunks, PyObject *__pyx_v_mask_chunks, PyObject *__pyx_v_np) {
  size_t __pyx_v_n;
  size_t __pyx_v_i;
  int __pyx_v_any_null;
  PyObject *__pyx_v_parts = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client._combine_hybrid_mask", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_parts);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1615:     cdef size_t n = <size_t>len(mask_chunks)

  if (unlikely(__pyx_v_mask_chunks == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(2, 1615, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_mask_chunks); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1615, __pyx_L1_error)
  __pyx_v_n = ((size_t)__pyx_t_1);

 1616:     cdef size_t i

+1617:     cdef bint any_null = False

  __pyx_v_any_null = 0;

+1618:     for i in range(n):

  __pyx_t_2 = __pyx_v_n;
  __pyx_t_3 = __pyx_t_2;
  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
    __pyx_v_i = __pyx_t_4;

+1619:         if mask_chunks[i] is not None:

    if (unlikely(__pyx_v_mask_chunks == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1619, __pyx_L1_error)
    }
    __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_mask_chunks, __pyx_v_i, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1619, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = (__pyx_t_5 != Py_None);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_6) {
/* … */
    }
  }
  __pyx_L4_break:;

+1620:             any_null = True

      __pyx_v_any_null = 1;

+1621:             break

      goto __pyx_L4_break;

+1622:     if not any_null:

  __pyx_t_6 = (!__pyx_v_any_null);
  if (__pyx_t_6) {
/* … */
  }

+1623:         return None

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

+1624:     parts = []

  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_v_parts = ((PyObject*)__pyx_t_5);
  __pyx_t_5 = 0;

+1625:     for i in range(n):

  __pyx_t_2 = __pyx_v_n;
  __pyx_t_3 = __pyx_t_2;
  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
    __pyx_v_i = __pyx_t_4;

+1626:         if mask_chunks[i] is None:

    if (unlikely(__pyx_v_mask_chunks == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1626, __pyx_L1_error)
    }
    __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_mask_chunks, __pyx_v_i, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1626, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = (__pyx_t_5 == Py_None);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_6) {
/* … */
      goto __pyx_L9;
    }

+1627:             parts.append(np.zeros(len(value_chunks[i]), dtype=bool))

      __pyx_t_7 = __pyx_v_np;
      __Pyx_INCREF(__pyx_t_7);
      if (unlikely(__pyx_v_value_chunks == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
        __PYX_ERR(2, 1627, __pyx_L1_error)
      }
      __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_value_chunks, __pyx_v_i, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1627, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_1 = PyObject_Length(__pyx_t_8); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1627, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = PyLong_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1627, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_8};
        __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1627, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, ((PyObject *)__pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool), __pyx_t_10, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1627, __pyx_L1_error)
        __pyx_t_5 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_zeros, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10);
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1627, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
      }
      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_parts, __pyx_t_5); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1627, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 1628:         else:

+1629:             parts.append(mask_chunks[i])

    /*else*/ {
      if (unlikely(__pyx_v_mask_chunks == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
        __PYX_ERR(2, 1629, __pyx_L1_error)
      }
      __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_mask_chunks, __pyx_v_i, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1629, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_parts, __pyx_t_5); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1629, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    }
    __pyx_L9:;
  }

+1630:     if len(parts) == 1:

  __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_parts); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1630, __pyx_L1_error)
  __pyx_t_6 = (__pyx_t_1 == 1);
  if (__pyx_t_6) {
/* … */
  }

+1631:         return parts[0]

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_parts, 0, long, 1, __Pyx_PyLong_From_long, 1, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1631, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_r = __pyx_t_5;
    __pyx_t_5 = 0;
    goto __pyx_L0;

+1632:     return np.concatenate(parts)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_10 = __pyx_v_np;
  __Pyx_INCREF(__pyx_t_10);
  __pyx_t_2 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_v_parts};
    __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_concatenate, __pyx_callargs+__pyx_t_2, (2-__pyx_t_2) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1632, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

 1633: 

 1634: 

+1635: cdef tuple _numpy_extract_meta(const qwp_reader_batch* batch):

static PyObject *__pyx_f_7questdb_7_client__numpy_extract_meta(struct qwp_reader_batch const *__pyx_v_batch) {
  size_t __pyx_v_n_cols;
  size_t __pyx_v_col_idx;
  enum qwp_reader_column_kind __pyx_v_kind;
  char const *__pyx_v_name_buf;
  size_t __pyx_v_name_len;
  questdb_error *__pyx_v_err;
  struct qwp_reader_column_data __pyx_v_cd_meta;
  int __pyx_v_has_symbol;
  PyObject *__pyx_v_col_names = NULL;
  PyObject *__pyx_v_col_kinds = NULL;
  PyObject *__pyx_v_col_scales = NULL;
  PyObject *__pyx_v_col_precision = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("questdb._client._numpy_extract_meta", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_col_names);
  __Pyx_XDECREF(__pyx_v_col_kinds);
  __Pyx_XDECREF(__pyx_v_col_scales);
  __Pyx_XDECREF(__pyx_v_col_precision);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1636:     cdef size_t n_cols = qwp_reader_batch_column_count(batch)

  __pyx_v_n_cols = qwp_reader_batch_column_count(__pyx_v_batch);

 1637:     cdef size_t col_idx

+1638:     cdef qwp_reader_column_kind kind = qwp_reader_column_kind_unknown

  __pyx_v_kind = qwp_reader_column_kind_unknown;

+1639:     cdef const char* name_buf = NULL

  __pyx_v_name_buf = NULL;

+1640:     cdef size_t name_len = 0

  __pyx_v_name_len = 0;

+1641:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1642:     cdef qwp_reader_column_data cd_meta

+1643:     cdef bint has_symbol = False

  __pyx_v_has_symbol = 0;

+1644:     col_names = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_names = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1645:     col_kinds = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1645, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_kinds = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1646:     col_scales = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_scales = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1647:     col_precision = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_precision = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1648:     for col_idx in range(n_cols):

  __pyx_t_2 = __pyx_v_n_cols;
  __pyx_t_3 = __pyx_t_2;
  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
    __pyx_v_col_idx = __pyx_t_4;

+1649:         _reader_check(

    __pyx_t_5 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_name(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_name_buf), (&__pyx_v_name_len), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_name); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 1649, __pyx_L1_error)

 1650:             qwp_reader_batch_column_name(

 1651:                 batch, col_idx, &name_buf, &name_len, &err),

 1652:             &err, 'qwp_reader_batch_column_name')

+1653:         col_names.append(

    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_col_names, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1653, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1654:             PyUnicode_FromStringAndSize(name_buf, <Py_ssize_t>name_len))

    __pyx_t_1 = PyUnicode_FromStringAndSize(__pyx_v_name_buf, ((Py_ssize_t)__pyx_v_name_len)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1654, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);

+1655:         _reader_check(

    __pyx_t_5 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_column_kind(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_kind), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_column_kind); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 1655, __pyx_L1_error)

 1656:             qwp_reader_batch_column_kind(batch, col_idx, &kind, &err),

 1657:             &err, 'qwp_reader_batch_column_kind')

+1658:         col_kinds.append(<int>kind)

    __pyx_t_1 = __Pyx_PyLong_From_int(((int)__pyx_v_kind)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1658, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_col_kinds, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1658, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1659:         col_scales.append(None)

    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_col_scales, Py_None); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1659, __pyx_L1_error)

+1660:         col_precision.append(None)

    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_col_precision, Py_None); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1660, __pyx_L1_error)

+1661:         if kind == qwp_reader_column_kind_symbol:

    switch (__pyx_v_kind) {
      case qwp_reader_column_kind_symbol:
/* … */
      break;
      case qwp_reader_column_kind_geohash:

+1662:             has_symbol = True

      __pyx_v_has_symbol = 1;

+1663:         elif (kind == qwp_reader_column_kind_geohash

      case qwp_reader_column_kind_decimal64:
/* … */
      break;
      default: break;
    }
  }

+1664:                 or kind == qwp_reader_column_kind_decimal64

      case qwp_reader_column_kind_decimal128:

+1665:                 or kind == qwp_reader_column_kind_decimal128

      case qwp_reader_column_kind_decimal256:

 1666:                 or kind == qwp_reader_column_kind_decimal256):

+1667:             if qwp_reader_batch_column_data(batch, col_idx, &cd_meta, &err):

      __pyx_t_7 = qwp_reader_batch_column_data(__pyx_v_batch, __pyx_v_col_idx, (&__pyx_v_cd_meta), (&__pyx_v_err));
      if (__pyx_t_7) {
/* … */
        goto __pyx_L5;
      }

+1668:                 if kind == qwp_reader_column_kind_geohash:

        __pyx_t_7 = (__pyx_v_kind == qwp_reader_column_kind_geohash);
        if (__pyx_t_7) {
/* … */
          goto __pyx_L6;
        }

+1669:                     col_precision[col_idx] = cd_meta.geohash_precision_bits

          __pyx_t_1 = __Pyx_PyLong_From_uint8_t(__pyx_v_cd_meta.geohash_precision_bits); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1669, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          if (unlikely((__Pyx_SetItemInt(__pyx_v_col_precision, __pyx_v_col_idx, __pyx_t_1, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(2, 1669, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1670:                 else:

+1671:                     col_scales[col_idx] = cd_meta.decimal_scale

        /*else*/ {
          __pyx_t_1 = __Pyx_PyLong_From_int8_t(__pyx_v_cd_meta.decimal_scale); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1671, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          if (unlikely((__Pyx_SetItemInt(__pyx_v_col_scales, __pyx_v_col_idx, __pyx_t_1, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(2, 1671, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        }
        __pyx_L6:;

+1672:             elif err != NULL:

      __pyx_t_7 = (__pyx_v_err != NULL);
      if (__pyx_t_7) {
/* … */
      }
      __pyx_L5:;

+1673:                 questdb_error_free(err)

        questdb_error_free(__pyx_v_err);

+1674:                 err = NULL

        __pyx_v_err = NULL;

+1675:     return (col_names, col_kinds, col_scales, col_precision, has_symbol)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_has_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1675, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_8 = PyTuple_New(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1675, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(__pyx_v_col_names);
  __Pyx_GIVEREF(__pyx_v_col_names);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_col_names) != (0)) __PYX_ERR(2, 1675, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_col_kinds);
  __Pyx_GIVEREF(__pyx_v_col_kinds);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_col_kinds) != (0)) __PYX_ERR(2, 1675, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_col_scales);
  __Pyx_GIVEREF(__pyx_v_col_scales);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_v_col_scales) != (0)) __PYX_ERR(2, 1675, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_col_precision);
  __Pyx_GIVEREF(__pyx_v_col_precision);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_v_col_precision) != (0)) __PYX_ERR(2, 1675, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_1);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_1) != (0)) __PYX_ERR(2, 1675, __pyx_L1_error);
  __pyx_t_1 = 0;
  __pyx_r = ((PyObject*)__pyx_t_8);
  __pyx_t_8 = 0;
  goto __pyx_L0;

 1676: 

 1677: 

+1678: cdef object _FROM_CODES_HAS_VALIDATE = None

  __Pyx_INCREF(Py_None);
  __Pyx_XGOTREF(__pyx_v_7questdb_7_client__FROM_CODES_HAS_VALIDATE);
  __Pyx_DECREF_SET(__pyx_v_7questdb_7_client__FROM_CODES_HAS_VALIDATE, Py_None);
  __Pyx_GIVEREF(Py_None);

 1679: 

 1680: 

+1681: cdef object _symbol_from_codes(object pd, object arr, object dtype):

static PyObject *__pyx_f_7questdb_7_client__symbol_from_codes(PyObject *__pyx_v_pd, PyObject *__pyx_v_arr, PyObject *__pyx_v_dtype) {
  Py_ssize_t __pyx_v_n_cats;
  PyObject *__pyx_v_inspect = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("questdb._client._symbol_from_codes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_inspect);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1682:     # Bounds-check the wire codes against the dict once (a vectorised C-level

 1683:     # reduction), then skip pandas' O(rows) Python re-validation. `validate=`

 1684:     # exists since pandas 1.1; older pandas keeps the checked path. `dtype=`

 1685:     # reuses one cached category Index across columns and batches (vs

 1686:     # `categories=`, which rebuilds it every call).

+1687:     cdef Py_ssize_t n_cats = len(dtype.categories)

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_mstate_global->__pyx_n_u_categories); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1687, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1687, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_n_cats = __pyx_t_2;

+1688:     if arr.size and <Py_ssize_t>int(arr.max()) >= n_cats:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1688, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(2, 1688, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_4) {
  } else {
    __pyx_t_3 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_5 = __pyx_v_arr;
  __Pyx_INCREF(__pyx_t_5);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_max, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1688, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_5 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1688, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1688, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_4 = (((Py_ssize_t)__pyx_t_2) >= __pyx_v_n_cats);
  __pyx_t_3 = __pyx_t_4;
  __pyx_L4_bool_binop_done:;
  if (unlikely(__pyx_t_3)) {
/* … */
  }

+1689:         raise QuestDBError(

    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1689, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);

+1690:             QuestDBErrorCode.ServerFlushError,

    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1690, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1690, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_7))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_7, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_9, __pyx_mstate_global->__pyx_kp_u_corrupt_symbol_codes_code_out_of};
      __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1689, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __PYX_ERR(2, 1689, __pyx_L1_error)

 1691:             'corrupt symbol codes: code out of dictionary range')

 1692:     global _FROM_CODES_HAS_VALIDATE

+1693:     if _FROM_CODES_HAS_VALIDATE is None:

  __pyx_t_3 = (__pyx_v_7questdb_7_client__FROM_CODES_HAS_VALIDATE == Py_None);
  if (__pyx_t_3) {
/* … */
  }

+1694:         import inspect

    __pyx_t_10 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_inspect, 0, 0, NULL, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1694, __pyx_L1_error)
    __pyx_t_5 = __pyx_t_10;
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_v_inspect = __pyx_t_5;
    __pyx_t_5 = 0;

 1695:         _FROM_CODES_HAS_VALIDATE = (

+1696:             'validate' in inspect.signature(

    __pyx_t_7 = __pyx_v_inspect;
    __Pyx_INCREF(__pyx_t_7);
/* … */
    __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1696, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XGOTREF(__pyx_v_7questdb_7_client__FROM_CODES_HAS_VALIDATE);
    __Pyx_DECREF_SET(__pyx_v_7questdb_7_client__FROM_CODES_HAS_VALIDATE, __pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_1);
    __pyx_t_1 = 0;

+1697:                 pd.Categorical.from_codes).parameters)

    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_pd, __pyx_mstate_global->__pyx_n_u_Categorical); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1697, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_from_codes); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1697, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_1};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_signature, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1696, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1697, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_validate, __pyx_t_1, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 1696, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1698:     if _FROM_CODES_HAS_VALIDATE:

  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_7questdb_7_client__FROM_CODES_HAS_VALIDATE); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 1698, __pyx_L1_error)
  if (__pyx_t_3) {
/* … */
  }

+1699:         return pd.Categorical.from_codes(arr, dtype=dtype, validate=False)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_pd, __pyx_mstate_global->__pyx_n_u_Categorical); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1699, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_5 = __pyx_t_7;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_5, __pyx_v_arr};
      __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1699, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_v_dtype, __pyx_t_9, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1699, __pyx_L1_error)
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_validate, Py_False, __pyx_t_9, __pyx_callargs+2, 1) < (0)) __PYX_ERR(2, 1699, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_from_codes, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1699, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

+1700:     return pd.Categorical.from_codes(arr, dtype=dtype)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_pd, __pyx_mstate_global->__pyx_n_u_Categorical); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1700, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_7 = __pyx_t_9;
  __Pyx_INCREF(__pyx_t_7);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_v_arr};
    __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1700, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_v_dtype, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1700, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_from_codes, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5);
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1700, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1701: 

 1702: 

+1703: cdef object _numpy_assemble_frame(

static PyObject *__pyx_f_7questdb_7_client__numpy_assemble_frame(PyObject *__pyx_v_col_names, PyObject *__pyx_v_col_kinds, PyObject *__pyx_v_col_scales, PyObject *__pyx_v_col_precision, PyObject *__pyx_v_col_chunks, PyObject *__pyx_v_symbol_categories, PyObject *__pyx_v_np, PyObject *__pyx_v_pd, PyObject *__pyx_v_col_masks, struct __pyx_opt_args_7questdb_7_client__numpy_assemble_frame *__pyx_optional_args) {
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_AddTraceback("questdb._client._numpy_assemble_frame", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_arrays);
  __Pyx_XDECREF(__pyx_v_chunks);
  __Pyx_XDECREF(__pyx_v_arr);
  __Pyx_XDECREF(__pyx_v_mask);
  __Pyx_XDECREF(__pyx_v_frame);
  __Pyx_XDECREF(__pyx_v_columns_meta);
  __Pyx_XDECREF(__pyx_v_entry);
  __Pyx_XDECREF(__pyx_v_symbol_dtype);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_opt_args_7questdb_7_client__numpy_assemble_frame {
  int __pyx_n;
  PyObject *symbol_dtype;
};

 1704:         list col_names, list col_kinds, list col_scales,

 1705:         list col_precision, list col_chunks, list symbol_categories,

+1706:         object np, object pd, list col_masks, object symbol_dtype=None):

  PyObject *__pyx_v_symbol_dtype = ((PyObject *)Py_None);
  size_t __pyx_v_n_cols;
  size_t __pyx_v_col_idx;
  enum qwp_reader_column_kind __pyx_v_kind;
  PyObject *__pyx_v_arrays = NULL;
  PyObject *__pyx_v_chunks = NULL;
  PyObject *__pyx_v_arr = NULL;
  PyObject *__pyx_v_mask = NULL;
  PyObject *__pyx_v_frame = NULL;
  PyObject *__pyx_v_columns_meta = NULL;
  PyObject *__pyx_v_entry = NULL;
  PyObject *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_symbol_dtype = __pyx_optional_args->symbol_dtype;
    }
  }
  __Pyx_INCREF(__pyx_v_symbol_dtype);

+1707:     cdef size_t n_cols = <size_t>len(col_names)

  if (unlikely(__pyx_v_col_names == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(2, 1707, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_col_names); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1707, __pyx_L1_error)
  __pyx_v_n_cols = ((size_t)__pyx_t_1);

 1708:     cdef size_t col_idx

 1709:     cdef qwp_reader_column_kind kind

+1710:     arrays = []

  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1710, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_arrays = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+1711:     for col_idx in range(n_cols):

  __pyx_t_3 = __pyx_v_n_cols;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_col_idx = __pyx_t_5;

+1712:         kind = <qwp_reader_column_kind><int>col_kinds[col_idx]

    if (unlikely(__pyx_v_col_kinds == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1712, __pyx_L1_error)
    }
    __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_col_kinds, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1712, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1712, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_kind = ((enum qwp_reader_column_kind)((int)__pyx_t_6));

+1713:         chunks = col_chunks[col_idx]

    if (unlikely(__pyx_v_col_chunks == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1713, __pyx_L1_error)
    }
    __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_col_chunks, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1713, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_chunks, __pyx_t_2);
    __pyx_t_2 = 0;

+1714:         if len(chunks) == 1:

    __pyx_t_1 = PyObject_Length(__pyx_v_chunks); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1714, __pyx_L1_error)
    __pyx_t_7 = (__pyx_t_1 == 1);
    if (__pyx_t_7) {
/* … */
      goto __pyx_L5;
    }

+1715:             arr = chunks[0]

      __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_chunks, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1715, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_XDECREF_SET(__pyx_v_arr, __pyx_t_2);
      __pyx_t_2 = 0;

 1716:         else:

+1717:             arr = np.concatenate(chunks)

    /*else*/ {
      __pyx_t_8 = __pyx_v_np;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_9 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_chunks};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_concatenate, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1717, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __Pyx_XDECREF_SET(__pyx_v_arr, __pyx_t_2);
      __pyx_t_2 = 0;
    }
    __pyx_L5:;

+1718:         if kind == qwp_reader_column_kind_symbol:

    __pyx_t_7 = (__pyx_v_kind == qwp_reader_column_kind_symbol);
    if (__pyx_t_7) {
/* … */
      goto __pyx_L6;
    }

 1719:             # Build the category Index once (here for fetch-all, or supplied

 1720:             # pre-built by `_NumpyBatchIter` across batches) and reuse it via

 1721:             # `dtype=` for every SYMBOL column, then build from the codes with no

 1722:             # bounds re-validation. Avoids the O(columns/batches x cardinality)

 1723:             # Index rebuild + validation the `categories=`/validate path costs.

+1724:             if symbol_dtype is None:

      __pyx_t_7 = (__pyx_v_symbol_dtype == Py_None);
      if (__pyx_t_7) {
/* … */
      }

+1725:                 symbol_dtype = pd.CategoricalDtype(symbol_categories)

        __pyx_t_8 = __pyx_v_pd;
        __Pyx_INCREF(__pyx_t_8);
        __pyx_t_9 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_symbol_categories};
          __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_CategoricalDtype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1725, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_2);
        }
        __Pyx_DECREF_SET(__pyx_v_symbol_dtype, __pyx_t_2);
        __pyx_t_2 = 0;

+1726:             arr = _symbol_from_codes(pd, arr, symbol_dtype)

      __pyx_t_2 = __pyx_f_7questdb_7_client__symbol_from_codes(__pyx_v_pd, __pyx_v_arr, __pyx_v_symbol_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1726, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF_SET(__pyx_v_arr, __pyx_t_2);
      __pyx_t_2 = 0;

+1727:         elif _is_hybrid_int(kind):

    __pyx_t_7 = __pyx_f_7questdb_7_client__is_hybrid_int(__pyx_v_kind); if (unlikely(__pyx_t_7 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1727, __pyx_L1_error)
    if (__pyx_t_7) {
/* … */
    }
    __pyx_L6:;

+1728:             mask = _combine_hybrid_mask(chunks, col_masks[col_idx], np)

      __pyx_t_2 = __pyx_v_chunks;
      __Pyx_INCREF(__pyx_t_2);
      if (!(likely(PyList_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_2))) __PYX_ERR(2, 1728, __pyx_L1_error)
      if (unlikely(__pyx_v_col_masks == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
        __PYX_ERR(2, 1728, __pyx_L1_error)
      }
      __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_col_masks, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1728, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (!(likely(PyList_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_8))) __PYX_ERR(2, 1728, __pyx_L1_error)
      __pyx_t_10 = __pyx_f_7questdb_7_client__combine_hybrid_mask(((PyObject*)__pyx_t_2), ((PyObject*)__pyx_t_8), __pyx_v_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1728, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_10);
      __pyx_t_10 = 0;

+1729:             if mask is not None:

      __pyx_t_7 = (__pyx_v_mask != Py_None);
      if (__pyx_t_7) {
/* … */
      }

+1730:                 arr = _build_nullable_array(arr, mask, kind, pd)

        __pyx_t_10 = __pyx_f_7questdb_7_client__build_nullable_array(__pyx_v_arr, __pyx_v_mask, __pyx_v_kind, __pyx_v_pd); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1730, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __Pyx_DECREF_SET(__pyx_v_arr, __pyx_t_10);
        __pyx_t_10 = 0;

+1731:         arrays.append(arr)

    __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_arrays, __pyx_v_arr); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 1731, __pyx_L1_error)
  }

+1732:     frame = pd.DataFrame(dict(enumerate(arrays)), copy=False)

  __pyx_t_8 = __pyx_v_pd;
  __Pyx_INCREF(__pyx_t_8);
  __pyx_t_12 = NULL;
  __pyx_t_14 = NULL;
  __pyx_t_3 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_v_arrays};
    __pyx_t_13 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_enumerate, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
    if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1732, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
  }
  __pyx_t_3 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_13};
    __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(&PyDict_Type), __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1732, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_8, __pyx_t_2};
    __pyx_t_13 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1732, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_copy, Py_False, __pyx_t_13, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1732, __pyx_L1_error)
    __pyx_t_10 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_DataFrame, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_13);
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1732, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }
  __pyx_v_frame = __pyx_t_10;
  __pyx_t_10 = 0;

 1733:     # Keep pandas 3 from inferring a pyarrow-backed StringDtype Index.

+1734:     frame.columns = pd.Index(col_names, dtype=object)

  __pyx_t_13 = __pyx_v_pd;
  __Pyx_INCREF(__pyx_t_13);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_13, __pyx_v_col_names};
    __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1734, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_builtin_object, __pyx_t_2, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1734, __pyx_L1_error)
    __pyx_t_10 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_Index, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2);
    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1734, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_mstate_global->__pyx_n_u_columns, __pyx_t_10) < (0)) __PYX_ERR(2, 1734, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+1735:     columns_meta = {}

  __pyx_t_10 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1735, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __pyx_v_columns_meta = ((PyObject*)__pyx_t_10);
  __pyx_t_10 = 0;

+1736:     for col_idx in range(n_cols):

  __pyx_t_3 = __pyx_v_n_cols;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_col_idx = __pyx_t_5;

+1737:         entry = {'kind': _KIND_NAMES.get(col_kinds[col_idx], 'unknown')}

    __pyx_t_10 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1737, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (unlikely(__pyx_v_7questdb_7_client__KIND_NAMES == Py_None)) {
      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get");
      __PYX_ERR(2, 1737, __pyx_L1_error)
    }
    if (unlikely(__pyx_v_col_kinds == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1737, __pyx_L1_error)
    }
    __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_col_kinds, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1737, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_13 = __Pyx_PyDict_GetItemDefault(__pyx_v_7questdb_7_client__KIND_NAMES, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_unknown); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1737, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_kind, __pyx_t_13) < (0)) __PYX_ERR(2, 1737, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_XDECREF_SET(__pyx_v_entry, ((PyObject*)__pyx_t_10));
    __pyx_t_10 = 0;

+1738:         if col_scales[col_idx] is not None:

    if (unlikely(__pyx_v_col_scales == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1738, __pyx_L1_error)
    }
    __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_col_scales, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1738, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_7 = (__pyx_t_10 != Py_None);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (__pyx_t_7) {
/* … */
    }

+1739:             entry['scale'] = col_scales[col_idx]

      if (unlikely(__pyx_v_col_scales == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
        __PYX_ERR(2, 1739, __pyx_L1_error)
      }
      __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_col_scales, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1739, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (unlikely((PyDict_SetItem(__pyx_v_entry, __pyx_mstate_global->__pyx_n_u_scale, __pyx_t_10) < 0))) __PYX_ERR(2, 1739, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+1740:         if col_precision[col_idx] is not None:

    if (unlikely(__pyx_v_col_precision == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1740, __pyx_L1_error)
    }
    __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_col_precision, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1740, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_7 = (__pyx_t_10 != Py_None);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (__pyx_t_7) {
/* … */
    }

+1741:             entry['precision_bits'] = col_precision[col_idx]

      if (unlikely(__pyx_v_col_precision == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
        __PYX_ERR(2, 1741, __pyx_L1_error)
      }
      __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_col_precision, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1741, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      if (unlikely((PyDict_SetItem(__pyx_v_entry, __pyx_mstate_global->__pyx_n_u_precision_bits, __pyx_t_10) < 0))) __PYX_ERR(2, 1741, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+1742:         columns_meta[col_names[col_idx]] = entry

    if (unlikely(__pyx_v_col_names == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1742, __pyx_L1_error)
    }
    __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_col_names, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1742, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (unlikely((PyDict_SetItem(__pyx_v_columns_meta, __pyx_t_10, __pyx_v_entry) < 0))) __PYX_ERR(2, 1742, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  }

+1743:     frame.attrs['questdb'] = {'version': 1, 'columns': columns_meta}

  __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_version, __pyx_mstate_global->__pyx_int_1) < (0)) __PYX_ERR(2, 1743, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_columns, __pyx_v_columns_meta) < (0)) __PYX_ERR(2, 1743, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_mstate_global->__pyx_n_u_attrs); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  if (unlikely((PyObject_SetItem(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_questdb, __pyx_t_10) < 0))) __PYX_ERR(2, 1743, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

+1744:     return frame

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_frame);
  __pyx_r = __pyx_v_frame;
  goto __pyx_L0;

 1745: 

 1746: 

+1747: cdef tuple _numpy_batch_columns(

static PyObject *__pyx_f_7questdb_7_client__numpy_batch_columns(struct qwp_reader_batch const *__pyx_v_batch, PyObject *__pyx_v_col_kinds, size_t __pyx_v_n_cols, size_t __pyx_v_row_count, PyObject *__pyx_v_np) {
  size_t __pyx_v_col_idx;
  enum qwp_reader_column_kind __pyx_v_kind;
  PyObject *__pyx_v_chunks = NULL;
  PyObject *__pyx_v_masks = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("questdb._client._numpy_batch_columns", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_chunks);
  __Pyx_XDECREF(__pyx_v_masks);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1748:         const qwp_reader_batch* batch, list col_kinds,

 1749:         size_t n_cols, size_t row_count, object np):

 1750:     cdef size_t col_idx

 1751:     cdef qwp_reader_column_kind kind

+1752:     chunks = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1752, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_chunks = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1753:     masks = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1753, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_masks = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1754:     for col_idx in range(n_cols):

  __pyx_t_2 = __pyx_v_n_cols;
  __pyx_t_3 = __pyx_t_2;
  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
    __pyx_v_col_idx = __pyx_t_4;

+1755:         kind = <qwp_reader_column_kind><int>col_kinds[col_idx]

    if (unlikely(__pyx_v_col_kinds == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 1755, __pyx_L1_error)
    }
    __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_col_kinds, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1755, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1755, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_kind = ((enum qwp_reader_column_kind)((int)__pyx_t_5));

+1756:         chunks.append(_numpy_column_chunk(batch, col_idx, kind, row_count, np))

    __pyx_t_1 = __pyx_f_7questdb_7_client__numpy_column_chunk(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_kind, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1756, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_chunks, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1756, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1757:         if _is_hybrid_int(kind):

    __pyx_t_7 = __pyx_f_7questdb_7_client__is_hybrid_int(__pyx_v_kind); if (unlikely(__pyx_t_7 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1757, __pyx_L1_error)
    if (__pyx_t_7) {
/* … */
      goto __pyx_L5;
    }

+1758:             masks.append(_numpy_validity_mask(batch, col_idx, row_count, np))

      __pyx_t_1 = __pyx_f_7questdb_7_client__numpy_validity_mask(__pyx_v_batch, __pyx_v_col_idx, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1758, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_masks, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1758, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1759:         else:

+1760:             masks.append(None)

    /*else*/ {
      __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_masks, Py_None); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1760, __pyx_L1_error)
    }
    __pyx_L5:;
  }

+1761:     return (chunks, masks)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1761, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_v_chunks);
  __Pyx_GIVEREF(__pyx_v_chunks);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_chunks) != (0)) __PYX_ERR(2, 1761, __pyx_L1_error);
  __Pyx_INCREF(__pyx_v_masks);
  __Pyx_GIVEREF(__pyx_v_masks);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_masks) != (0)) __PYX_ERR(2, 1761, __pyx_L1_error);
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1762: 

 1763: 

+1764: cdef object _numpy_frame_from_cursor(_CursorHandle handle):

static PyObject *__pyx_f_7questdb_7_client__numpy_frame_from_cursor(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle) {
  PyObject *__pyx_v_np = NULL;
  PyObject *__pyx_v_pd = NULL;
  struct qwp_reader_cursor *__pyx_v_cursor;
  questdb_error *__pyx_v_err;
  struct qwp_reader_batch const *__pyx_v_batch;
  struct qwp_reader_symbol_dict __pyx_v_sd;
  size_t __pyx_v_n_cols;
  size_t __pyx_v_row_count;
  size_t __pyx_v_col_idx;
  size_t __pyx_v_prev_dict_n;
  int __pyx_v_first;
  int __pyx_v_has_symbol;
  int __pyx_v_seen_seq;
  PyObject *__pyx_v_col_names = NULL;
  PyObject *__pyx_v_col_kinds = NULL;
  PyObject *__pyx_v_col_scales = NULL;
  PyObject *__pyx_v_col_precision = NULL;
  PyObject *__pyx_v_col_chunks = NULL;
  PyObject *__pyx_v_col_masks = NULL;
  PyObject *__pyx_v_symbol_categories = NULL;
  PyObject *__pyx_v_batch_chunks = NULL;
  PyObject *__pyx_v_batch_masks = NULL;
  CYTHON_UNUSED size_t __pyx_8genexpr3__pyx_v__;
  CYTHON_UNUSED size_t __pyx_8genexpr4__pyx_v__;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_AddTraceback("questdb._client._numpy_frame_from_cursor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_np);
  __Pyx_XDECREF(__pyx_v_pd);
  __Pyx_XDECREF(__pyx_v_col_names);
  __Pyx_XDECREF(__pyx_v_col_kinds);
  __Pyx_XDECREF(__pyx_v_col_scales);
  __Pyx_XDECREF(__pyx_v_col_precision);
  __Pyx_XDECREF(__pyx_v_col_chunks);
  __Pyx_XDECREF(__pyx_v_col_masks);
  __Pyx_XDECREF(__pyx_v_symbol_categories);
  __Pyx_XDECREF(__pyx_v_batch_chunks);
  __Pyx_XDECREF(__pyx_v_batch_masks);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1765:     import numpy as np

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1765, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_np = __pyx_t_1;
  __pyx_t_1 = 0;

+1766:     import pandas as pd

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pandas, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1766, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_pd = __pyx_t_1;
  __pyx_t_1 = 0;

 1767:     cdef qwp_reader_cursor* cursor

+1768:     cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 1769:     cdef const qwp_reader_batch* batch

 1770:     cdef qwp_reader_symbol_dict sd

+1771:     cdef size_t n_cols = 0

  __pyx_v_n_cols = 0;

+1772:     cdef size_t row_count = 0

  __pyx_v_row_count = 0;

 1773:     cdef size_t col_idx

+1774:     cdef size_t prev_dict_n = 0

  __pyx_v_prev_dict_n = 0;

+1775:     cdef bint first = True

  __pyx_v_first = 1;

+1776:     cdef bint has_symbol = False

  __pyx_v_has_symbol = 0;

 1777:     cdef int seen_seq

 1778: 

+1779:     if handle is None or handle._cursor == NULL:

  __pyx_t_4 = (((PyObject *)__pyx_v_handle) == Py_None);
  if (!__pyx_t_4) {
  } else {
    __pyx_t_3 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_4 = (__pyx_v_handle->_cursor == NULL);
  __pyx_t_3 = __pyx_t_4;
  __pyx_L4_bool_binop_done:;
  if (unlikely(__pyx_t_3)) {
/* … */
  }

+1780:         raise QuestDBError(QuestDBErrorCode.InvalidApiCall, 'cursor is closed')

    __pyx_t_5 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1780, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1780, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1780, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_5);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_8, __pyx_mstate_global->__pyx_kp_u_cursor_is_closed};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1780, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 1780, __pyx_L1_error)

+1781:     seen_seq = handle._reset_seq

  __pyx_t_10 = __pyx_v_handle->_reset_seq;
  __pyx_v_seen_seq = __pyx_t_10;

 1782: 

+1783:     col_names = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1783, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_names = __pyx_t_1;
  __pyx_t_1 = 0;

+1784:     col_kinds = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1784, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_kinds = __pyx_t_1;
  __pyx_t_1 = 0;

+1785:     col_scales = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1785, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_scales = __pyx_t_1;
  __pyx_t_1 = 0;

+1786:     col_precision = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1786, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_precision = __pyx_t_1;
  __pyx_t_1 = 0;

+1787:     col_chunks = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1787, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_chunks = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1788:     col_masks = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1788, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_col_masks = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1789:     symbol_categories = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1789, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_symbol_categories = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 1790: 

+1791:     try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
    goto __pyx_L11_try_end;
    __pyx_L6_error:;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* … */
    __pyx_L8_except_error:;
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_11);
    __Pyx_XGIVEREF(__pyx_t_12);
    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_11, __pyx_t_12);
    goto __pyx_L1_error;
    __pyx_L11_try_end:;
  }

+1792:         while True:

      while (1) {

+1793:             with handle._lock:

        /*with:*/ {
          __pyx_t_13 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1793, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_6 = NULL;
          __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1793, __pyx_L14_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_9 = 1;
          #if CYTHON_UNPACK_METHODS
          if (likely(PyMethod_Check(__pyx_t_8))) {
            __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_8);
            assert(__pyx_t_6);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
            __Pyx_INCREF(__pyx_t_6);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
            __pyx_t_9 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL};
            __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1793, __pyx_L14_error)
            __Pyx_GOTREF(__pyx_t_1);
          }
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          /*try:*/ {
            {
              /*try:*/ {
/* … */
              }
              __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
              __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
              __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
              goto __pyx_L27_try_end;
              __pyx_L20_error:;
              __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
              __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
              /*except:*/ {
                __Pyx_AddTraceback("questdb._client._numpy_frame_from_cursor", __pyx_clineno, __pyx_lineno, __pyx_filename);
                if (__Pyx_GetException(&__pyx_t_18, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(2, 1793, __pyx_L22_except_error)
                __Pyx_XGOTREF(__pyx_t_18);
                __Pyx_XGOTREF(__pyx_t_5);
                __Pyx_XGOTREF(__pyx_t_1);
                __pyx_t_8 = PyTuple_Pack(3, __pyx_t_18, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1793, __pyx_L22_except_error)
                __Pyx_GOTREF(__pyx_t_8);
                __pyx_t_22 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_8, NULL);
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                if (unlikely(!__pyx_t_22)) __PYX_ERR(2, 1793, __pyx_L22_except_error)
                __Pyx_GOTREF(__pyx_t_22);
                __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_22);
                __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
                if (__pyx_t_3 < (0)) __PYX_ERR(2, 1793, __pyx_L22_except_error)
                __pyx_t_4 = (!__pyx_t_3);
                if (unlikely(__pyx_t_4)) {
                  __Pyx_GIVEREF(__pyx_t_18);
                  __Pyx_GIVEREF(__pyx_t_5);
                  __Pyx_XGIVEREF(__pyx_t_1);
                  __Pyx_ErrRestoreWithState(__pyx_t_18, __pyx_t_5, __pyx_t_1);
                  __pyx_t_18 = 0;  __pyx_t_5 = 0;  __pyx_t_1 = 0; 
                  __PYX_ERR(2, 1793, __pyx_L22_except_error)
                }
                __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
                __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
                __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
                goto __pyx_L21_exception_handled;
              }
              __pyx_L22_except_error:;
              __Pyx_XGIVEREF(__pyx_t_14);
              __Pyx_XGIVEREF(__pyx_t_15);
              __Pyx_XGIVEREF(__pyx_t_16);
              __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
              goto __pyx_L6_error;
              __pyx_L25_try_break:;
              __Pyx_XGIVEREF(__pyx_t_14);
              __Pyx_XGIVEREF(__pyx_t_15);
              __Pyx_XGIVEREF(__pyx_t_16);
              __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
              goto __pyx_L16_break;
              __pyx_L21_exception_handled:;
              __Pyx_XGIVEREF(__pyx_t_14);
              __Pyx_XGIVEREF(__pyx_t_15);
              __Pyx_XGIVEREF(__pyx_t_16);
              __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
              __pyx_L27_try_end:;
            }
          }
          /*finally:*/ {
            /*normal exit:*/{
              if (__pyx_t_13) {
                __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_mstate_global->__pyx_tuple[2], NULL);
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 1793, __pyx_L6_error)
                __Pyx_GOTREF(__pyx_t_16);
                __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
              }
              goto __pyx_L19;
            }
            __pyx_L16_break: {
              if (__pyx_t_13) {
                __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_mstate_global->__pyx_tuple[2], NULL);
                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
                if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 1793, __pyx_L6_error)
                __Pyx_GOTREF(__pyx_t_16);
                __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
              }
              goto __pyx_L13_break;
            }
            __pyx_L19:;
          }
          goto __pyx_L47;
          __pyx_L14_error:;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          goto __pyx_L6_error;
          __pyx_L47:;
        }

+1794:                 cursor = handle._cursor

                __pyx_t_17 = __pyx_v_handle->_cursor;
                __pyx_v_cursor = __pyx_t_17;

+1795:                 if cursor == NULL:

                __pyx_t_3 = (__pyx_v_cursor == NULL);
                if (unlikely(__pyx_t_3)) {
/* … */
                }

+1796:                     raise QuestDBError(

                  __pyx_t_8 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1796, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_6);

+1797:                         QuestDBErrorCode.InvalidApiCall, 'cursor is closed')

                  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1797, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1797, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_7);
                  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
                  __pyx_t_9 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_6))) {
                    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
                    assert(__pyx_t_8);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
                    __Pyx_INCREF(__pyx_t_8);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
                    __pyx_t_9 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_7, __pyx_mstate_global->__pyx_kp_u_cursor_is_closed};
                    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
                    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
                    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1796, __pyx_L20_error)
                    __Pyx_GOTREF(__pyx_t_1);
                  }
                  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
                  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                  __PYX_ERR(2, 1796, __pyx_L20_error)

+1798:                 with nogil:

                {
                    PyThreadState * _save;
                    _save = PyEval_SaveThread();
                    __Pyx_FastGIL_Remember();
                    /*try:*/ {
/* … */
                    /*finally:*/ {
                      /*normal exit:*/{
                        __Pyx_FastGIL_Forget();
                        PyEval_RestoreThread(_save);
                        goto __pyx_L33;
                      }
                      __pyx_L33:;
                    }
                }

+1799:                     batch = qwp_reader_cursor_next_batch(cursor, &err)

                      __pyx_v_batch = qwp_reader_cursor_next_batch(__pyx_v_cursor, (&__pyx_v_err));
                    }

+1800:                 if handle._reset_seq != seen_seq:

                __pyx_t_3 = (__pyx_v_handle->_reset_seq != __pyx_v_seen_seq);
                if (__pyx_t_3) {
/* … */
                }

 1801:                     # Mid-query failover replayed from batch-0: discard the

 1802:                     # pre-failover accumulation and re-derive the schema.

+1803:                     seen_seq = handle._reset_seq

                  __pyx_t_10 = __pyx_v_handle->_reset_seq;
                  __pyx_v_seen_seq = __pyx_t_10;

+1804:                     first = True

                  __pyx_v_first = 1;

+1805:                     prev_dict_n = 0

                  __pyx_v_prev_dict_n = 0;

+1806:                     has_symbol = False

                  __pyx_v_has_symbol = 0;

+1807:                     col_chunks = []

                  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1807, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __Pyx_DECREF_SET(__pyx_v_col_chunks, ((PyObject*)__pyx_t_1));
                  __pyx_t_1 = 0;

+1808:                     col_masks = []

                  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1808, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __Pyx_DECREF_SET(__pyx_v_col_masks, ((PyObject*)__pyx_t_1));
                  __pyx_t_1 = 0;

+1809:                     symbol_categories = []

                  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1809, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __Pyx_DECREF_SET(__pyx_v_symbol_categories, ((PyObject*)__pyx_t_1));
                  __pyx_t_1 = 0;

+1810:                 if batch == NULL:

                __pyx_t_3 = (__pyx_v_batch == NULL);
                if (__pyx_t_3) {
/* … */
                }

+1811:                     if err != NULL:

                  __pyx_t_3 = (__pyx_v_err != NULL);
                  if (unlikely(__pyx_t_3)) {
/* … */
                  }

+1812:                         raise _reader_err_to_py(err)

                    __pyx_t_1 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1812, __pyx_L20_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                    __PYX_ERR(2, 1812, __pyx_L20_error)

+1813:                     break

                  goto __pyx_L25_try_break;

+1814:                 row_count = qwp_reader_batch_row_count(batch)

                __pyx_v_row_count = qwp_reader_batch_row_count(__pyx_v_batch);

+1815:                 if first:

                if (__pyx_v_first) {
/* … */
                }

+1816:                     (col_names, col_kinds, col_scales, col_precision,

                  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 1816, __pyx_L20_error)
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                  __Pyx_DECREF_SET(__pyx_v_col_names, __pyx_t_6);
                  __pyx_t_6 = 0;
                  __Pyx_DECREF_SET(__pyx_v_col_kinds, __pyx_t_7);
                  __pyx_t_7 = 0;
                  __Pyx_DECREF_SET(__pyx_v_col_scales, __pyx_t_8);
                  __pyx_t_8 = 0;
                  __Pyx_DECREF_SET(__pyx_v_col_precision, __pyx_t_5);
                  __pyx_t_5 = 0;
                  __pyx_v_has_symbol = __pyx_t_3;

+1817:                      has_symbol) = _numpy_extract_meta(batch)

                  __pyx_t_1 = __pyx_f_7questdb_7_client__numpy_extract_meta(__pyx_v_batch); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1817, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  if (likely(__pyx_t_1 != Py_None)) {
                    PyObject* sequence = __pyx_t_1;
                    Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
                    if (unlikely(size != 5)) {
                      if (size > 5) __Pyx_RaiseTooManyValuesError(5);
                      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                      __PYX_ERR(2, 1816, __pyx_L20_error)
                    }
                    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                    __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0);
                    __Pyx_INCREF(__pyx_t_6);
                    __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
                    __Pyx_INCREF(__pyx_t_7);
                    __pyx_t_8 = PyTuple_GET_ITEM(sequence, 2);
                    __Pyx_INCREF(__pyx_t_8);
                    __pyx_t_5 = PyTuple_GET_ITEM(sequence, 3);
                    __Pyx_INCREF(__pyx_t_5);
                    __pyx_t_18 = PyTuple_GET_ITEM(sequence, 4);
                    __Pyx_INCREF(__pyx_t_18);
                    #else
                    {
                      Py_ssize_t i;
                      PyObject** temps[5] = {&__pyx_t_6,&__pyx_t_7,&__pyx_t_8,&__pyx_t_5,&__pyx_t_18};
                      for (i=0; i < 5; i++) {
                        PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(2, 1816, __pyx_L20_error)
                        __Pyx_GOTREF(item);
                        *(temps[i]) = item;
                      }
                    }
                    #endif
                    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                  } else {
                    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 1816, __pyx_L20_error)
                  }

+1818:                     n_cols = <size_t>len(col_names)

                  __pyx_t_19 = PyObject_Length(__pyx_v_col_names); if (unlikely(__pyx_t_19 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1818, __pyx_L20_error)
                  __pyx_v_n_cols = ((size_t)__pyx_t_19);

+1819:                     col_chunks = [[] for _ in range(n_cols)]

                  { /* enter inner scope */
                    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1819, __pyx_L20_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __pyx_t_9 = __pyx_v_n_cols;
                    __pyx_t_20 = __pyx_t_9;
                    for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) {
                      __pyx_8genexpr3__pyx_v__ = __pyx_t_21;
                      __pyx_t_18 = PyList_New(0); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 1819, __pyx_L20_error)
                      __Pyx_GOTREF(__pyx_t_18);
                      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_18))) __PYX_ERR(2, 1819, __pyx_L20_error)
                      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                    }
                  } /* exit inner scope */
                  __Pyx_DECREF_SET(__pyx_v_col_chunks, ((PyObject*)__pyx_t_1));
                  __pyx_t_1 = 0;

+1820:                     col_masks = [[] for _ in range(n_cols)]

                  { /* enter inner scope */
                    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1820, __pyx_L20_error)
                    __Pyx_GOTREF(__pyx_t_1);
                    __pyx_t_9 = __pyx_v_n_cols;
                    __pyx_t_20 = __pyx_t_9;
                    for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) {
                      __pyx_8genexpr4__pyx_v__ = __pyx_t_21;
                      __pyx_t_18 = PyList_New(0); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 1820, __pyx_L20_error)
                      __Pyx_GOTREF(__pyx_t_18);
                      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_18))) __PYX_ERR(2, 1820, __pyx_L20_error)
                      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                    }
                  } /* exit inner scope */
                  __Pyx_DECREF_SET(__pyx_v_col_masks, ((PyObject*)__pyx_t_1));
                  __pyx_t_1 = 0;

+1821:                     first = False

                  __pyx_v_first = 0;

+1822:                 if has_symbol:

                if (__pyx_v_has_symbol) {
/* … */
                }

+1823:                     _reader_check(

                  __pyx_t_10 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_symbol_dict(__pyx_v_batch, (&__pyx_v_sd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_symbol_dict); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 1823, __pyx_L20_error)

 1824:                         qwp_reader_batch_symbol_dict(batch, &sd, &err), &err,

 1825:                         'qwp_reader_batch_symbol_dict')

+1826:                     if sd.entry_count > prev_dict_n:

                  __pyx_t_3 = (__pyx_v_sd.entry_count > __pyx_v_prev_dict_n);
                  if (__pyx_t_3) {
/* … */
                  }

+1827:                         _symbol_categories_extend(

                    __pyx_f_7questdb_7_client__symbol_categories_extend(__pyx_v_symbol_categories, (&__pyx_v_sd), __pyx_v_prev_dict_n); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 1827, __pyx_L20_error)

 1828:                             symbol_categories, &sd, prev_dict_n)

+1829:                         prev_dict_n = sd.entry_count

                    __pyx_t_9 = __pyx_v_sd.entry_count;
                    __pyx_v_prev_dict_n = __pyx_t_9;

+1830:                 batch_chunks, batch_masks = _numpy_batch_columns(

                __pyx_t_18 = __pyx_f_7questdb_7_client__numpy_batch_columns(__pyx_v_batch, ((PyObject*)__pyx_t_1), __pyx_v_n_cols, __pyx_v_row_count, __pyx_v_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 1830, __pyx_L20_error)
                __Pyx_GOTREF(__pyx_t_18);
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                if (likely(__pyx_t_18 != Py_None)) {
                  PyObject* sequence = __pyx_t_18;
                  Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
                  if (unlikely(size != 2)) {
                    if (size > 2) __Pyx_RaiseTooManyValuesError(2);
                    else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                    __PYX_ERR(2, 1830, __pyx_L20_error)
                  }
                  #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                  __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0);
                  __Pyx_INCREF(__pyx_t_1);
                  __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1);
                  __Pyx_INCREF(__pyx_t_5);
                  #else
                  __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1830, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_1);
                  __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1830, __pyx_L20_error)
                  __Pyx_GOTREF(__pyx_t_5);
                  #endif
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                } else {
                  __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 1830, __pyx_L20_error)
                }
                __Pyx_XDECREF_SET(__pyx_v_batch_chunks, __pyx_t_1);
                __pyx_t_1 = 0;
                __Pyx_XDECREF_SET(__pyx_v_batch_masks, __pyx_t_5);
                __pyx_t_5 = 0;

+1831:                     batch, col_kinds, n_cols, row_count, np)

                __pyx_t_1 = __pyx_v_col_kinds;
                __Pyx_INCREF(__pyx_t_1);
                if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(2, 1831, __pyx_L20_error)

+1832:             for col_idx in range(n_cols):

        __pyx_t_9 = __pyx_v_n_cols;
        __pyx_t_20 = __pyx_t_9;
        for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) {
          __pyx_v_col_idx = __pyx_t_21;

+1833:                 col_chunks[col_idx].append(batch_chunks[col_idx])

          __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_col_chunks, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1833, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_1);
          if (unlikely(!__pyx_v_batch_chunks)) { __Pyx_RaiseUnboundLocalError("batch_chunks"); __PYX_ERR(2, 1833, __pyx_L6_error) }
          __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_batch_chunks, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1833, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_23 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_t_5); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(2, 1833, __pyx_L6_error)
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+1834:                 col_masks[col_idx].append(batch_masks[col_idx])

          __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_col_masks, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 1, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1834, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_5);
          if (unlikely(!__pyx_v_batch_masks)) { __Pyx_RaiseUnboundLocalError("batch_masks"); __PYX_ERR(2, 1834, __pyx_L6_error) }
          __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_batch_masks, __pyx_v_col_idx, size_t, 0, __Pyx_PyLong_FromSize_t, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1834, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_23 = __Pyx_PyObject_Append(__pyx_t_5, __pyx_t_1); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(2, 1834, __pyx_L6_error)
          __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        }
      }
      __pyx_L13_break:;

+1835:     except:

    /*except:*/ {
      __Pyx_AddTraceback("questdb._client._numpy_frame_from_cursor", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_18) < 0) __PYX_ERR(2, 1835, __pyx_L8_except_error)
      __Pyx_XGOTREF(__pyx_t_1);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_18);

+1836:         handle._free()

      ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_handle->__pyx_vtab)->_free(__pyx_v_handle);

+1837:         raise

      __Pyx_GIVEREF(__pyx_t_1);
      __Pyx_GIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_18);
      __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_5, __pyx_t_18);
      __pyx_t_1 = 0;  __pyx_t_5 = 0;  __pyx_t_18 = 0; 
      __PYX_ERR(2, 1837, __pyx_L8_except_error)
    }

 1838: 

+1839:     _mark_reader_drained(handle)

  __pyx_f_7questdb_7_client__mark_reader_drained(__pyx_v_handle);

+1840:     handle._free()

  ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_handle->__pyx_vtab)->_free(__pyx_v_handle);

 1841: 

+1842:     if first:

  if (__pyx_v_first) {
/* … */
  }

+1843:         return pd.DataFrame()

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = __pyx_v_pd;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_18 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_DataFrame, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 1843, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_18);
    }
    __pyx_r = __pyx_t_18;
    __pyx_t_18 = 0;
    goto __pyx_L0;

+1844:     return _numpy_assemble_frame(

  __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_7 = __pyx_f_7questdb_7_client__numpy_assemble_frame(((PyObject*)__pyx_t_18), ((PyObject*)__pyx_t_5), ((PyObject*)__pyx_t_1), ((PyObject*)__pyx_t_8), __pyx_v_col_chunks, __pyx_v_symbol_categories, __pyx_v_np, __pyx_v_pd, __pyx_v_col_masks, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

+1845:         col_names, col_kinds, col_scales, col_precision,

  __pyx_t_18 = __pyx_v_col_names;
  __Pyx_INCREF(__pyx_t_18);
  if (!(likely(PyList_CheckExact(__pyx_t_18))||((__pyx_t_18) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_18))) __PYX_ERR(2, 1845, __pyx_L1_error)
  __pyx_t_5 = __pyx_v_col_kinds;
  __Pyx_INCREF(__pyx_t_5);
  if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_5))) __PYX_ERR(2, 1845, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_col_scales;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(2, 1845, __pyx_L1_error)
  __pyx_t_8 = __pyx_v_col_precision;
  __Pyx_INCREF(__pyx_t_8);
  if (!(likely(PyList_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_8))) __PYX_ERR(2, 1845, __pyx_L1_error)

 1846:         col_chunks, symbol_categories, np, pd, col_masks)

 1847: 

 1848: 

+1849: cdef class _PolarsSymbolRegistry:

struct __pyx_obj_7questdb_7_client__PolarsSymbolRegistry {
  PyObject_HEAD
  PyObject *pl;
  PyObject *cats;
  PyObject *base;
  PyObject *pinned;
  Py_ssize_t n;
  int cat_to;
};

 1850:     """A polars ``Categories`` shared by every SYMBOL column on the same

 1851:     (append-only) connection dictionary — interned once and grown as the dict

 1852:     grows, so a QWP code is its own physical categorical code and casts straight

 1853:     into a ``Categorical`` with no per-row remap (the Rust ``SymbolRegistry``

 1854:     analog). The interned dictionary is pinned in ``base`` to stop polars'

 1855:     auto-GC mapping from dropping it between calls."""

 1856:     cdef object pl

 1857:     cdef object cats

 1858:     cdef object base

 1859:     cdef object pinned

 1860:     cdef Py_ssize_t n

 1861:     cdef bint cat_to

 1862: 

+1863:     def __cinit__(self, object pl):

/* Python wrapper */
static int __pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_pl = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pl,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 1863, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 1863, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(2, 1863, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, i); __PYX_ERR(2, 1863, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 1863, __pyx_L3_error)
    }
    __pyx_v_pl = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 1863, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client._PolarsSymbolRegistry.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_21_PolarsSymbolRegistry___cinit__(((struct __pyx_obj_7questdb_7_client__PolarsSymbolRegistry *)__pyx_v_self), __pyx_v_pl);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_7questdb_7_client_21_PolarsSymbolRegistry___cinit__(struct __pyx_obj_7questdb_7_client__PolarsSymbolRegistry *__pyx_v_self, PyObject *__pyx_v_pl) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("questdb._client._PolarsSymbolRegistry.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+1864:         self.pl = pl

  __Pyx_INCREF(__pyx_v_pl);
  __Pyx_GIVEREF(__pyx_v_pl);
  __Pyx_GOTREF(__pyx_v_self->pl);
  __Pyx_DECREF(__pyx_v_self->pl);
  __pyx_v_self->pl = __pyx_v_pl;

+1865:         self.cats = pl.Categories.random('questdb_symbol', physical=pl.UInt32)

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_pl, __pyx_mstate_global->__pyx_n_u_Categories); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_pl, __pyx_mstate_global->__pyx_n_u_UInt32); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_questdb_symbol};
    __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1865, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_physical, __pyx_t_4, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1865, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_random, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1865, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->cats);
  __Pyx_DECREF(__pyx_v_self->cats);
  __pyx_v_self->cats = __pyx_t_1;
  __pyx_t_1 = 0;

+1866:         self.base = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->base);
  __Pyx_DECREF(__pyx_v_self->base);
  __pyx_v_self->base = Py_None;

+1867:         self.pinned = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->pinned);
  __Pyx_DECREF(__pyx_v_self->pinned);
  __pyx_v_self->pinned = Py_None;

+1868:         self.n = 0

  __pyx_v_self->n = 0;

 1869:         # polars >= 1.43 deprecates the physical-code `.cast(Categorical)` in

 1870:         # favour of `.cat.to(Categorical)`, which older polars lacks.

+1871:         self.cat_to = hasattr(pl.Series([], dtype=pl.UInt32).cat, 'to')

  __pyx_t_3 = __pyx_v_pl;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_pl, __pyx_mstate_global->__pyx_n_u_UInt32); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_6};
    __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1871, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_2, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1871, __pyx_L1_error)
    __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_Series, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1871, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_cat); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_7 = __Pyx_HasAttr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_to); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(2, 1871, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_self->cat_to = __pyx_t_7;

 1872: 

+1873:     def accepts(self, object cats_arrow):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_3accepts(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_21_PolarsSymbolRegistry_3accepts = {"accepts", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_3accepts, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_3accepts(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_cats_arrow = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("accepts (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_cats_arrow,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 1873, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 1873, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "accepts", 0) < (0)) __PYX_ERR(2, 1873, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("accepts", 1, 1, 1, i); __PYX_ERR(2, 1873, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 1873, __pyx_L3_error)
    }
    __pyx_v_cats_arrow = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("accepts", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 1873, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client._PolarsSymbolRegistry.accepts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_21_PolarsSymbolRegistry_2accepts(((struct __pyx_obj_7questdb_7_client__PolarsSymbolRegistry *)__pyx_v_self), __pyx_v_cats_arrow);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_21_PolarsSymbolRegistry_2accepts(struct __pyx_obj_7questdb_7_client__PolarsSymbolRegistry *__pyx_v_self, PyObject *__pyx_v_cats_arrow) {
  Py_ssize_t __pyx_v_m;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("questdb._client._PolarsSymbolRegistry.accepts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_21_PolarsSymbolRegistry_3accepts, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PolarsSymbolRegistry_accepts, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7questdb_7_client__PolarsSymbolRegistry, __pyx_mstate_global->__pyx_n_u_accepts, __pyx_t_4) < (0)) __PYX_ERR(2, 1873, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 1874:         # True if this registry's Categories maps `cats_arrow`'s codes

 1875:         # correctly: the smaller of (pinned, cats_arrow) must be a prefix of the

 1876:         # larger. The connection dict is append-only, so columns sharing it only

 1877:         # ever differ by a growth suffix; a column-local dict fails the check and

 1878:         # gets its own registry. `equals` short-circuits on the shared buffer.

 1879:         cdef Py_ssize_t m

+1880:         if self.pinned is None:

  __pyx_t_1 = (__pyx_v_self->pinned == Py_None);
  if (__pyx_t_1) {
/* … */
  }

+1881:             return True

    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_True);
    __pyx_r = Py_True;
    goto __pyx_L0;

+1882:         m = len(cats_arrow)

  __pyx_t_2 = PyObject_Length(__pyx_v_cats_arrow); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1882, __pyx_L1_error)
  __pyx_v_m = __pyx_t_2;

+1883:         if m <= self.n:

  __pyx_t_1 = (__pyx_v_m <= __pyx_v_self->n);
  if (__pyx_t_1) {
/* … */
  }

+1884:             return self.pinned.slice(0, m).equals(cats_arrow)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_6 = __pyx_v_self->pinned;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_7 = PyLong_FromSsize_t(__pyx_v_m); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1884, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_7};
      __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_slice, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1884, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
    }
    __pyx_t_4 = __pyx_t_5;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_cats_arrow};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_equals, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1884, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_r = __pyx_t_3;
    __pyx_t_3 = 0;
    goto __pyx_L0;

+1885:         return cats_arrow.slice(0, self.n).equals(self.pinned)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_7 = __pyx_v_cats_arrow;
  __Pyx_INCREF(__pyx_t_7);
  __pyx_t_6 = PyLong_FromSsize_t(__pyx_v_self->n); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_6};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_slice, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1885, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_5 = __pyx_t_4;
  __Pyx_INCREF(__pyx_t_5);
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_self->pinned};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_equals, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1885, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 1886: 

+1887:     def column(self, object name, object codes, object cats_arrow):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_5column(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_21_PolarsSymbolRegistry_5column = {"column", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_5column, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_21_PolarsSymbolRegistry_5column(PyObject *__pyx_v_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_name = 0;
  PyObject *__pyx_v_codes = 0;
  PyObject *__pyx_v_cats_arrow = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("column (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,&__pyx_mstate_global->__pyx_n_u_codes,&__pyx_mstate_global->__pyx_n_u_cats_arrow,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 1887, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 1887, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 1887, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 1887, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "column", 0) < (0)) __PYX_ERR(2, 1887, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("column", 1, 3, 3, i); __PYX_ERR(2, 1887, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 1887, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 1887, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 1887, __pyx_L3_error)
    }
    __pyx_v_name = values[0];
    __pyx_v_codes = values[1];
    __pyx_v_cats_arrow = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("column", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 1887, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client._PolarsSymbolRegistry.column", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_21_PolarsSymbolRegistry_4column(((struct __pyx_obj_7questdb_7_client__PolarsSymbolRegistry *)__pyx_v_self), __pyx_v_name, __pyx_v_codes, __pyx_v_cats_arrow);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_21_PolarsSymbolRegistry_4column(struct __pyx_obj_7questdb_7_client__PolarsSymbolRegistry *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_codes, PyObject *__pyx_v_cats_arrow) {
  PyObject *__pyx_v_pl = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_INCREF(__pyx_v_codes);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("questdb._client._PolarsSymbolRegistry.column", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pl);
  __Pyx_XDECREF(__pyx_v_codes);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_21_PolarsSymbolRegistry_5column, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PolarsSymbolRegistry_column, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4);
  #endif
  if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7questdb_7_client__PolarsSymbolRegistry, __pyx_mstate_global->__pyx_n_u_column_2, __pyx_t_4) < (0)) __PYX_ERR(2, 1887, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+1888:         cdef object pl = self.pl

  __pyx_t_1 = __pyx_v_self->pl;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_pl = __pyx_t_1;
  __pyx_t_1 = 0;

+1889:         if cats_arrow is not None and len(cats_arrow) > self.n:

  __pyx_t_3 = (__pyx_v_cats_arrow != Py_None);
  if (__pyx_t_3) {
  } else {
    __pyx_t_2 = __pyx_t_3;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_4 = PyObject_Length(__pyx_v_cats_arrow); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1889, __pyx_L1_error)
  __pyx_t_3 = (__pyx_t_4 > __pyx_v_self->n);
  __pyx_t_2 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_2) {
/* … */
  }

+1890:             self.base = pl.Series(

    __pyx_t_5 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_5);
/* … */
    __Pyx_GIVEREF(__pyx_t_1);
    __Pyx_GOTREF(__pyx_v_self->base);
    __Pyx_DECREF(__pyx_v_self->base);
    __pyx_v_self->base = __pyx_t_1;
    __pyx_t_1 = 0;

+1891:                 pl.from_arrow(cats_arrow), dtype=pl.Categorical(self.cats))

    __pyx_t_7 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_cats_arrow};
      __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1891, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    __pyx_t_9 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_self->cats};
      __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Categorical, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1891, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_6};
      __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1890, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_9, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1890, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_Series, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1890, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }

+1892:             self.pinned = cats_arrow

    __Pyx_INCREF(__pyx_v_cats_arrow);
    __Pyx_GIVEREF(__pyx_v_cats_arrow);
    __Pyx_GOTREF(__pyx_v_self->pinned);
    __Pyx_DECREF(__pyx_v_self->pinned);
    __pyx_v_self->pinned = __pyx_v_cats_arrow;

+1893:             self.n = len(cats_arrow)

    __pyx_t_4 = PyObject_Length(__pyx_v_cats_arrow); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1893, __pyx_L1_error)
    __pyx_v_self->n = __pyx_t_4;

+1894:         codes = codes.cast(pl.UInt32)

  __pyx_t_9 = __pyx_v_codes;
  __Pyx_INCREF(__pyx_t_9);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_pl, __pyx_mstate_global->__pyx_n_u_UInt32); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1894, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_7};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_cast, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1894, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF_SET(__pyx_v_codes, __pyx_t_1);
  __pyx_t_1 = 0;

+1895:         if self.cat_to:

  if (__pyx_v_self->cat_to) {
/* … */
  }

+1896:             return codes.cat.to(pl.Categorical(self.cats)).alias(name)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_codes, __pyx_mstate_global->__pyx_n_u_cat); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1896, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __pyx_t_5;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_11 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_11);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_v_self->cats};
      __pyx_t_10 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Categorical, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1896, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
    }
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_10};
      __pyx_t_9 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1896, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __pyx_t_7 = __pyx_t_9;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_name};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_alias, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1896, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

+1897:         return codes.cast(pl.Categorical(self.cats)).alias(name)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_v_codes;
  __Pyx_INCREF(__pyx_t_5);
  __pyx_t_6 = __pyx_v_pl;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_self->cats};
    __pyx_t_10 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Categorical, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 1897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
  }
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_10};
    __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_cast, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
  }
  __pyx_t_9 = __pyx_t_7;
  __Pyx_INCREF(__pyx_t_9);
  __pyx_t_8 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_name};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_alias, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1897, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1898: 

 1899: 

+1900: cdef tuple _polars_dict_codes_cats(object col, object pl):

static PyObject *__pyx_f_7questdb_7_client__polars_dict_codes_cats(PyObject *__pyx_v_col, PyObject *__pyx_v_pl) {
  PyObject *__pyx_v_chunks = 0;
  PyObject *__pyx_v_parts = 0;
  PyObject *__pyx_v_ch = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("questdb._client._polars_dict_codes_cats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_chunks);
  __Pyx_XDECREF(__pyx_v_parts);
  __Pyx_XDECREF(__pyx_v_ch);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1901:     # col: a pyarrow ChunkedArray of dictionary type, one chunk per wire batch.

 1902:     # The dict is append-only and shared across the query — the Rust egress

 1903:     # attaches the full active connection dict to every batch and only ever grows

 1904:     # it (see `SymbolValuesCache` in c-questdb-client), and `Table.from_batches`

 1905:     # keeps the chunks in emission order — so the last chunk's dictionary is the

 1906:     # largest and covers every (global, stable) code. Returns (polars Series of

 1907:     # the dict indices with nulls preserved via Arrow validity, the full

 1908:     # dictionary values array). The indices flow straight from Arrow to polars

 1909:     # (no numpy round-trip, no -1 sentinel).

+1910:     cdef list chunks = col.chunks

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_col, __pyx_mstate_global->__pyx_n_u_chunks); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1910, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(2, 1910, __pyx_L1_error)
  __pyx_v_chunks = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1911:     cdef list parts = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_parts = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 1912:     cdef object ch

+1913:     if not chunks:

  if (__pyx_v_chunks == Py_None) __pyx_t_2 = 0;
  else
  {
    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_chunks);
    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(2, 1913, __pyx_L1_error)
    __pyx_t_2 = (__pyx_temp != 0);
  }

  __pyx_t_3 = (!__pyx_t_2);
  if (__pyx_t_3) {
/* … */
  }

+1914:         return (pl.Series([], dtype=pl.UInt32), None)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1914, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_pl, __pyx_mstate_global->__pyx_n_u_UInt32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1914, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_5};
      __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1914, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1914, __pyx_L1_error)
      __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_Series, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1914, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1914, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_GIVEREF(__pyx_t_1);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 1914, __pyx_L1_error);
    __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(Py_None);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, Py_None) != (0)) __PYX_ERR(2, 1914, __pyx_L1_error);
    __pyx_t_1 = 0;
    __pyx_r = ((PyObject*)__pyx_t_8);
    __pyx_t_8 = 0;
    goto __pyx_L0;

+1915:     for ch in chunks:

  if (unlikely(__pyx_v_chunks == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(2, 1915, __pyx_L1_error)
  }
  __pyx_t_8 = __pyx_v_chunks; __Pyx_INCREF(__pyx_t_8);
  __pyx_t_9 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 1915, __pyx_L1_error)
      #endif
      if (__pyx_t_9 >= __pyx_temp) break;
    }
    __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_8, __pyx_t_9, __Pyx_ReferenceSharing_OwnStrongReference);
    ++__pyx_t_9;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1915, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_ch, __pyx_t_1);
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+1916:         parts.append(pl.from_arrow(ch.indices))

    __pyx_t_6 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_ch, __pyx_mstate_global->__pyx_n_u_indices); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1916, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1916, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_parts, __pyx_t_1); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 1916, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+1917:     return (pl.concat(parts) if len(parts) > 1 else parts[0],

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_9 = __Pyx_PyList_GET_SIZE(__pyx_v_parts); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1917, __pyx_L1_error)
  __pyx_t_3 = (__pyx_t_9 > 1);
  if (__pyx_t_3) {
    __pyx_t_5 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_parts};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_concat, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1917, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_8 = __pyx_t_1;
    __pyx_t_1 = 0;
  } else {
    __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_parts, 0, long, 1, __Pyx_PyLong_From_long, 1, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1917, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_8 = __pyx_t_1;
    __pyx_t_1 = 0;
  }
/* … */
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_8);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_8) != (0)) __PYX_ERR(2, 1917, __pyx_L1_error);
  __Pyx_GIVEREF(__pyx_t_5);
  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5) != (0)) __PYX_ERR(2, 1917, __pyx_L1_error);
  __pyx_t_8 = 0;
  __pyx_t_5 = 0;
  __pyx_r = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

+1918:             chunks[-1].dictionary)

  if (unlikely(__pyx_v_chunks == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
    __PYX_ERR(2, 1918, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_chunks, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1918, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_dictionary); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1918, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 1919: 

 1920: 

+1921: cdef object _cast_to_string_view(object col, object svt, object pa, object pc):

static PyObject *__pyx_f_7questdb_7_client__cast_to_string_view(PyObject *__pyx_v_col, PyObject *__pyx_v_svt, PyObject *__pyx_v_pa, PyObject *__pyx_v_pc) {
  PyObject *__pyx_v_chunks = 0;
  PyObject *__pyx_v_empty = 0;
  PyObject *__pyx_v_ch = 0;
  PyObject *__pyx_v_view = 0;
  PyObject *__pyx_v_bufs = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("questdb._client._cast_to_string_view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_chunks);
  __Pyx_XDECREF(__pyx_v_empty);
  __Pyx_XDECREF(__pyx_v_ch);
  __Pyx_XDECREF(__pyx_v_view);
  __Pyx_XDECREF(__pyx_v_bufs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_7questdb_7_client_23_polars_nonsymbol_frame_2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */

 1922:     # Cast a Utf8 / LargeUtf8 ChunkedArray to Arrow ``string_view``, repairing the

 1923:     # null trailing variadic data buffer that pyarrow's cast leaves behind for a

 1924:     # chunk whose every value is inline (<= 12 bytes). The null buffer validates

 1925:     # fine in-process, but the Arrow C-Data-Interface exporter dereferences it

 1926:     # unconditionally — so it crashes (SIGSEGV) the moment polars re-exports the

 1927:     # column across the C-ABI. Swapping the null for a shared 0-length buffer is

 1928:     # zero-copy and makes the export safe. A natively built string_view already

 1929:     # uses an empty (non-null) buffer here, so only the cast output needs fixing.

+1930:     cdef list chunks = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1930, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_chunks = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+1931:     cdef object empty = None

  __Pyx_INCREF(Py_None);
  __pyx_v_empty = Py_None;

 1932:     cdef object ch, view, bufs

+1933:     for ch in col.chunks:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_col, __pyx_mstate_global->__pyx_n_u_chunks); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1933, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1933, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1933, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 1933, __pyx_L1_error)
          #endif
          if (__pyx_t_3 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_3;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 1933, __pyx_L1_error)
          #endif
          if (__pyx_t_3 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3);
        #endif
        ++__pyx_t_3;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1933, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_4(__pyx_t_2);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 1933, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_ch, __pyx_t_1);
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+1934:         view = pc.cast(ch, svt)

    __pyx_t_5 = __pyx_v_pc;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_ch, __pyx_v_svt};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_cast, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1934, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_XDECREF_SET(__pyx_v_view, __pyx_t_1);
    __pyx_t_1 = 0;

+1935:         bufs = view.buffers()

    __pyx_t_5 = __pyx_v_view;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_buffers, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1935, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_XDECREF_SET(__pyx_v_bufs, __pyx_t_1);
    __pyx_t_1 = 0;

+1936:         if bufs and bufs[-1] is None:

    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_bufs); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 1936, __pyx_L1_error)
    if (__pyx_t_8) {
    } else {
      __pyx_t_7 = __pyx_t_8;
      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_bufs, -1L, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1936, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_8 = (__pyx_t_1 == Py_None);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_7 = __pyx_t_8;
    __pyx_L6_bool_binop_done:;
    if (__pyx_t_7) {
/* … */
    }

+1937:             if empty is None:

      __pyx_t_7 = (__pyx_v_empty == Py_None);
      if (__pyx_t_7) {
/* … */
      }

+1938:                 empty = pa.allocate_buffer(0)

        __pyx_t_5 = __pyx_v_pa;
        __Pyx_INCREF(__pyx_t_5);
        __pyx_t_6 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0};
          __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_allocate_buffer, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1938, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __Pyx_DECREF_SET(__pyx_v_empty, __pyx_t_1);
        __pyx_t_1 = 0;

+1939:             view = pa.Array.from_buffers(

      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_Array); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1939, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_5 = __pyx_t_9;
      __Pyx_INCREF(__pyx_t_5);

+1940:                 svt, len(view), bufs[:-1] + [empty],

      __pyx_t_10 = PyObject_Length(__pyx_v_view); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1940, __pyx_L1_error)
      __pyx_t_11 = PyLong_FromSsize_t(__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 1940, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = __Pyx_PyObject_GetSlice(__pyx_v_bufs, 0, -1L, NULL, NULL, &__pyx_mstate_global->__pyx_slice[1], 0, 1, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1940, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_13 = PyList_New(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1940, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_INCREF(__pyx_v_empty);
      __Pyx_GIVEREF(__pyx_v_empty);
      if (__Pyx_PyList_SET_ITEM(__pyx_t_13, 0, __pyx_v_empty) != (0)) __PYX_ERR(2, 1940, __pyx_L1_error);
      __pyx_t_14 = PyNumber_Add(__pyx_t_12, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 1940, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_14);
      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
/* … */
  __pyx_mstate_global->__pyx_slice[1] = PySlice_New(Py_None, __pyx_mstate_global->__pyx_int_neg_1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[1])) __PYX_ERR(2, 1940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[1]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[1]);

+1941:                 null_count=view.null_count, offset=view.offset)

      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_view, __pyx_mstate_global->__pyx_n_u_null_count); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1941, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_view, __pyx_mstate_global->__pyx_n_u_offset); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1941, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_6 = 0;
      {
        PyObject *__pyx_callargs[4 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_5, __pyx_v_svt, __pyx_t_11, __pyx_t_14};
        __pyx_t_15 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 1939, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_15);
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_null_count, __pyx_t_13, __pyx_t_15, __pyx_callargs+4, 0) < (0)) __PYX_ERR(2, 1939, __pyx_L1_error)
        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_offset, __pyx_t_12, __pyx_t_15, __pyx_callargs+4, 1) < (0)) __PYX_ERR(2, 1939, __pyx_L1_error)
        __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_from_buffers, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_15);
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1939, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __Pyx_DECREF_SET(__pyx_v_view, __pyx_t_1);
      __pyx_t_1 = 0;

+1942:         chunks.append(view)

    __pyx_t_16 = __Pyx_PyList_Append(__pyx_v_chunks, __pyx_v_view); if (unlikely(__pyx_t_16 == ((int)-1))) __PYX_ERR(2, 1942, __pyx_L1_error)

+1943:     return pa.chunked_array(chunks, type=svt)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_v_pa;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_6 = 0;
  {
    PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, __pyx_v_chunks};
    __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 1943, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_type, __pyx_v_svt, __pyx_t_9, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 1943, __pyx_L1_error)
    __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_n_u_chunked_array, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1943, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 1944: 

 1945: 

+1946: cdef object _polars_nonsymbol_frame(

static PyObject *__pyx_f_7questdb_7_client__polars_nonsymbol_frame(PyObject *__pyx_v_table, PyObject *__pyx_v_nd_idx, PyObject *__pyx_v_pl, PyObject *__pyx_v_pa) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame *__pyx_cur_scope;
  PyObject *__pyx_v_tbl = 0;
  PyObject *__pyx_v_types = 0;
  PyObject *__pyx_v_sv = 0;
  PyObject *__pyx_v_svt = 0;
  Py_ssize_t __pyx_v_j;
  PyObject *__pyx_v_pc = NULL;
  PyObject *__pyx_gb_7questdb_7_client_23_polars_nonsymbol_frame_2generator4 = 0;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 1946, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_pa = __pyx_v_pa;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_pa);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pa);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_14);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_AddTraceback("questdb._client._polars_nonsymbol_frame", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tbl);
  __Pyx_XDECREF(__pyx_v_types);
  __Pyx_XDECREF(__pyx_v_sv);
  __Pyx_XDECREF(__pyx_v_svt);
  __Pyx_XDECREF(__pyx_v_pc);
  __Pyx_XDECREF(__pyx_gb_7questdb_7_client_23_polars_nonsymbol_frame_2generator4);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame {
  PyObject_HEAD
  PyObject *__pyx_v_pa;
};

 1947:         object table, list nd_idx, object pl, object pa):

 1948:     # `pl.from_arrow` for the non-SYMBOL columns. Utf8 / LargeUtf8 columns are

 1949:     # first cast to Arrow `string_view` (when pyarrow exposes it) so polars

 1950:     # adopts the byte/view buffers zero-copy — its `String` dtype *is* the view

 1951:     # ("German strings") layout — instead of rebuilding the view from the offset

 1952:     # layout. Fixed-width columns are already adopted zero-copy.

+1953:     if not nd_idx:

  if (__pyx_v_nd_idx == Py_None) __pyx_t_1 = 0;
  else
  {
    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_nd_idx);
    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(2, 1953, __pyx_L1_error)
    __pyx_t_1 = (__pyx_temp != 0);
  }

  __pyx_t_2 = (!__pyx_t_1);
  if (__pyx_t_2) {
/* … */
  }

+1954:         return None

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

+1955:     cdef object tbl = table.select(nd_idx)

  __pyx_t_4 = __pyx_v_table;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_nd_idx};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_select, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_v_tbl = __pyx_t_3;
  __pyx_t_3 = 0;

+1956:     cdef object types = tbl.schema.types

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_tbl, __pyx_mstate_global->__pyx_n_u_schema); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1956, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1956, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_types = __pyx_t_4;
  __pyx_t_4 = 0;

+1957:     cdef object sv = getattr(pa, 'string_view', None)

  __pyx_t_4 = __pyx_cur_scope->__pyx_v_pa;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_GetAttr3(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_string_view, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1957, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_sv = __pyx_t_3;
  __pyx_t_3 = 0;

 1958:     cdef object svt

 1959:     cdef Py_ssize_t j

+1960:     if sv is not None and any(

      __Pyx_XDECREF(__pyx_r);
/* … */
    __Pyx_XDECREF(__pyx_r);
/* … */
  __pyx_t_1 = (__pyx_v_sv != Py_None);
  if (__pyx_t_1) {
  } else {
    __pyx_t_2 = __pyx_t_1;
    goto __pyx_L5_bool_binop_done;
  }
/* … */
  if (__pyx_t_2) {
/* … */
  }

+1961:             pa.types.is_string(t) or pa.types.is_large_string(t) for t in types):

static PyObject *__pyx_pf_7questdb_7_client_23_polars_nonsymbol_frame_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_5_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_5_genexpr *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct_5_genexpr(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct_5_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct_5_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 1961, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame *) __pyx_self;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7questdb_7_client_23_polars_nonsymbol_frame_2generator4, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_polars_nonsymbol_frame_locals_g, __pyx_mstate_global->__pyx_n_u_questdb__client); if (unlikely(!gen)) __PYX_ERR(2, 1961, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("questdb._client._polars_nonsymbol_frame.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_7questdb_7_client_23_polars_nonsymbol_frame_2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 1961, __pyx_L1_error)
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(2, 1961, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1961, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1961, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 1961, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 1961, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1961, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 1961, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_t);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_t, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
    if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_pa)) { __Pyx_RaiseClosureNameError("pa"); __PYX_ERR(2, 1961, __pyx_L1_error) }
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1961, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_6 = __pyx_t_7;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_t};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_string, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1961, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 1961, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (!__pyx_t_9) {
    } else {
      __pyx_t_5 = __pyx_t_9;
      goto __pyx_L7_bool_binop_done;
    }
    if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_pa)) { __Pyx_RaiseClosureNameError("pa"); __PYX_ERR(2, 1961, __pyx_L1_error) }
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1961, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __pyx_t_6;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_8 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_cur_scope->__pyx_v_t};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_large_string, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1961, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 1961, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = __pyx_t_9;
    __pyx_L7_bool_binop_done:;
    if (__pyx_t_5) {
/* … */
      __Pyx_INCREF(Py_True);
      __pyx_r = Py_True;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  /*else*/ {
/* … */
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_3 = __pyx_pf_7questdb_7_client_23_polars_nonsymbol_frame_genexpr(((PyObject*)__pyx_cur_scope), __pyx_v_types); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1961, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_Generator_GetInlinedResult(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1961, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(2, 1961, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __pyx_t_1;
  __pyx_L5_bool_binop_done:;
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct_5_genexpr {
  PyObject_HEAD
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_4___pyx_f_7questdb_7_client__polars_nonsymbol_frame *__pyx_outer_scope;
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_t;
};

+1962:         import pyarrow.compute as pc

    __pyx_t_6 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow_compute, 0, 0, NULL, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1962, __pyx_L1_error)
    __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_compute);
    Py_DECREF(__pyx_t_6);
    if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 1962, __pyx_L1_error)
    __pyx_t_6 = __pyx_t_7;
    __pyx_t_4 = __pyx_t_6;
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_v_pc = __pyx_t_4;
    __pyx_t_4 = 0;

+1963:         svt = sv()

    __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_v_sv);
    __pyx_t_8 = __pyx_v_sv; 
    __pyx_t_5 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_5 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
      __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1963, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_v_svt = __pyx_t_4;
    __pyx_t_4 = 0;

+1964:         for j in range(len(types)):

    __pyx_t_9 = PyObject_Length(__pyx_v_types); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1964, __pyx_L1_error)
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
      __pyx_v_j = __pyx_t_11;

+1965:             if pa.types.is_string(types[j]) or pa.types.is_large_string(types[j]):

      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1965, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_8 = __pyx_t_3;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_12 = __Pyx_GetItemInt(__pyx_v_types, __pyx_v_j, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1965, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_12};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_string, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1965, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(2, 1965, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (!__pyx_t_1) {
      } else {
        __pyx_t_2 = __pyx_t_1;
        goto __pyx_L10_bool_binop_done;
      }
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 1965, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_3 = __pyx_t_12;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_types, __pyx_v_j, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1965, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_8};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_large_string, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1965, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(2, 1965, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_2 = __pyx_t_1;
      __pyx_L10_bool_binop_done:;
      if (__pyx_t_2) {
/* … */
      }
    }

+1966:                 tbl = tbl.set_column(

        __pyx_t_12 = __pyx_v_tbl;
        __Pyx_INCREF(__pyx_t_12);

+1967:                     j, tbl.schema.field(j).with_type(svt),

        __pyx_t_8 = PyLong_FromSsize_t(__pyx_v_j); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1967, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_tbl, __pyx_mstate_global->__pyx_n_u_schema); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 1967, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_16);
        __pyx_t_15 = __pyx_t_16;
        __Pyx_INCREF(__pyx_t_15);
        __pyx_t_17 = PyLong_FromSsize_t(__pyx_v_j); if (unlikely(!__pyx_t_17)) __PYX_ERR(2, 1967, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_15, __pyx_t_17};
          __pyx_t_14 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_field, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
          if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 1967, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_14);
        }
        __pyx_t_13 = __pyx_t_14;
        __Pyx_INCREF(__pyx_t_13);
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_v_svt};
          __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_with_type, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
          if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1967, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
        }

+1968:                     _cast_to_string_view(tbl.column(j), svt, pa, pc))

        __pyx_t_13 = __pyx_v_tbl;
        __Pyx_INCREF(__pyx_t_13);
        __pyx_t_16 = PyLong_FromSsize_t(__pyx_v_j); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 1968, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_16);
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_16};
          __pyx_t_14 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_column_2, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
          if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 1968, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_14);
        }
        __pyx_t_16 = __pyx_cur_scope->__pyx_v_pa;
        __Pyx_INCREF(__pyx_t_16);
        __pyx_t_13 = __pyx_f_7questdb_7_client__cast_to_string_view(__pyx_t_14, __pyx_v_svt, __pyx_t_16, __pyx_v_pc); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 1968, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
        __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
        __pyx_t_5 = 0;
        {
          PyObject *__pyx_callargs[4] = {__pyx_t_12, __pyx_t_8, __pyx_t_3, __pyx_t_13};
          __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_set_column, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1966, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF_SET(__pyx_v_tbl, __pyx_t_4);
        __pyx_t_4 = 0;

+1969:     return pl.from_arrow(tbl)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_13 = __pyx_v_pl;
  __Pyx_INCREF(__pyx_t_13);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_v_tbl};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1969, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 1970: 

 1971: 

+1972: cdef object _polars_dataframe_hybrid(

static PyObject *__pyx_f_7questdb_7_client__polars_dataframe_hybrid(PyObject *__pyx_v_table, PyObject *__pyx_v_pl, PyObject *__pyx_v_pa, PyObject *__pyx_v_registries) {
  PyObject *__pyx_v_types = 0;
  PyObject *__pyx_v_is_dict = 0;
  PyObject *__pyx_v_names = 0;
  PyObject *__pyx_v_nd_idx = 0;
  PyObject *__pyx_v_nd = NULL;
  PyObject *__pyx_v_cols = 0;
  Py_ssize_t __pyx_v_i;
  PyObject *__pyx_v_codes = 0;
  PyObject *__pyx_v_cats = 0;
  PyObject *__pyx_v_reg = 0;
  PyObject *__pyx_v_shared = 0;
  PyObject *__pyx_8genexpr6__pyx_v_t = NULL;
  Py_ssize_t __pyx_8genexpr7__pyx_v_i;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("questdb._client._polars_dataframe_hybrid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_types);
  __Pyx_XDECREF(__pyx_v_is_dict);
  __Pyx_XDECREF(__pyx_v_names);
  __Pyx_XDECREF(__pyx_v_nd_idx);
  __Pyx_XDECREF(__pyx_v_nd);
  __Pyx_XDECREF(__pyx_v_cols);
  __Pyx_XDECREF(__pyx_v_codes);
  __Pyx_XDECREF(__pyx_v_cats);
  __Pyx_XDECREF(__pyx_v_reg);
  __Pyx_XDECREF(__pyx_v_shared);
  __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_t);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1973:         object table, object pl, object pa, dict registries):

 1974:     # SYMBOL (dictionary) columns are built from codes + dict via a `Categories`

 1975:     # registry (low CPU, no per-row remap); every other column keeps its exact

 1976:     # `pl.from_arrow` dtype. One shared registry (key -1) serves every column on

 1977:     # the connection dict — interned once, not per column — and falls back to a

 1978:     # per-column registry for a column-local dict. `registries` persists across

 1979:     # batches so a streaming `iter_polars` stitches via one `Categories`.

+1980:     cdef list types = table.schema.types

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_table, __pyx_mstate_global->__pyx_n_u_schema); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1980, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1980, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (!(likely(PyList_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_2))) __PYX_ERR(2, 1980, __pyx_L1_error)
  __pyx_v_types = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+1981:     cdef list is_dict = [pa.types.is_dictionary(t) for t in types]

  { /* enter inner scope */
    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1981, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (unlikely(__pyx_v_types == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
      __PYX_ERR(2, 1981, __pyx_L5_error)
    }
    __pyx_t_1 = __pyx_v_types; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_3 = 0;
    for (;;) {
      {
        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 1981, __pyx_L5_error)
        #endif
        if (__pyx_t_3 >= __pyx_temp) break;
      }
      __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference);
      ++__pyx_t_3;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1981, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_8genexpr6__pyx_v_t, __pyx_t_4);
      __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_types); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 1981, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_6);
      __pyx_t_5 = __pyx_t_6;
      __Pyx_INCREF(__pyx_t_5);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_8genexpr6__pyx_v_t};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_dictionary, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1981, __pyx_L5_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(2, 1981, __pyx_L5_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_t); __pyx_8genexpr6__pyx_v_t = 0;
    goto __pyx_L9_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_t); __pyx_8genexpr6__pyx_v_t = 0;
    goto __pyx_L1_error;
    __pyx_L9_exit_scope:;
  } /* exit inner scope */
  __pyx_v_is_dict = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+1982:     if not any(is_dict):

  __pyx_t_1 = NULL;
  __pyx_t_7 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_is_dict};
    __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_any, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1982, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 1982, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_9 = (!__pyx_t_8);
  if (__pyx_t_9) {
/* … */
  }

+1983:         return pl.from_arrow(table)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_7 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_table};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1983, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+1984:     cdef list names = table.column_names

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_table, __pyx_mstate_global->__pyx_n_u_column_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (!(likely(PyList_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_2))) __PYX_ERR(2, 1984, __pyx_L1_error)
  __pyx_v_names = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+1985:     cdef list nd_idx = [i for i in range(len(types)) if not is_dict[i]]

  { /* enter inner scope */
    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1985, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    if (unlikely(__pyx_v_types == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
      __PYX_ERR(2, 1985, __pyx_L1_error)
    }
    __pyx_t_3 = __Pyx_PyList_GET_SIZE(__pyx_v_types); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1985, __pyx_L1_error)
    __pyx_t_10 = __pyx_t_3;
    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
      __pyx_8genexpr7__pyx_v_i = __pyx_t_11;
      __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_is_dict, __pyx_8genexpr7__pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1985, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 1985, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __pyx_t_8 = (!__pyx_t_9);
      if (__pyx_t_8) {
        __pyx_t_1 = PyLong_FromSsize_t(__pyx_8genexpr7__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1985, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_1))) __PYX_ERR(2, 1985, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      }
    }
  } /* exit inner scope */
  __pyx_v_nd_idx = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

+1986:     nd = _polars_nonsymbol_frame(table, nd_idx, pl, pa)

  __pyx_t_2 = __pyx_f_7questdb_7_client__polars_nonsymbol_frame(__pyx_v_table, __pyx_v_nd_idx, __pyx_v_pl, __pyx_v_pa); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1986, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_nd = __pyx_t_2;
  __pyx_t_2 = 0;

+1987:     cdef list cols = []

  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1987, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_cols = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 1988:     cdef Py_ssize_t i

 1989:     cdef object codes, cats, reg

+1990:     cdef object shared = registries.get(-1)

  if (unlikely(__pyx_v_registries == Py_None)) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get");
    __PYX_ERR(2, 1990, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_v_registries, __pyx_mstate_global->__pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1990, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_shared = __pyx_t_2;
  __pyx_t_2 = 0;

+1991:     for i in range(len(types)):

  if (unlikely(__pyx_v_types == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(2, 1991, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyList_GET_SIZE(__pyx_v_types); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 1991, __pyx_L1_error)
  __pyx_t_10 = __pyx_t_3;
  for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
    __pyx_v_i = __pyx_t_11;

+1992:         if is_dict[i]:

    __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_is_dict, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1992, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 1992, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_8) {
/* … */
      goto __pyx_L16;
    }

+1993:             codes, cats = _polars_dict_codes_cats(table.column(i), pl)

      __pyx_t_1 = __pyx_v_table;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_4 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1993, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_column_2, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1993, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_t_4 = __pyx_f_7questdb_7_client__polars_dict_codes_cats(__pyx_t_2, __pyx_v_pl); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1993, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (likely(__pyx_t_4 != Py_None)) {
        PyObject* sequence = __pyx_t_4;
        Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
        if (unlikely(size != 2)) {
          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
          __PYX_ERR(2, 1993, __pyx_L1_error)
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
        __Pyx_INCREF(__pyx_t_2);
        __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1);
        __Pyx_INCREF(__pyx_t_1);
        #else
        __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1993, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1993, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        #endif
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      } else {
        __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 1993, __pyx_L1_error)
      }
      __Pyx_XDECREF_SET(__pyx_v_codes, __pyx_t_2);
      __pyx_t_2 = 0;
      __Pyx_XDECREF_SET(__pyx_v_cats, __pyx_t_1);
      __pyx_t_1 = 0;

+1994:             if shared is None:

      __pyx_t_8 = (__pyx_v_shared == Py_None);
      if (__pyx_t_8) {
/* … */
      }

+1995:                 shared = _PolarsSymbolRegistry(pl)

        __pyx_t_1 = NULL;
        __pyx_t_7 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_pl};
          __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_7questdb_7_client__PolarsSymbolRegistry, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1995, __pyx_L1_error)
          __Pyx_GOTREF((PyObject *)__pyx_t_4);
        }
        __Pyx_DECREF_SET(__pyx_v_shared, ((PyObject *)__pyx_t_4));
        __pyx_t_4 = 0;

+1996:                 registries[-1] = shared

        if (unlikely(__pyx_v_registries == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
          __PYX_ERR(2, 1996, __pyx_L1_error)
        }
        if (unlikely((PyDict_SetItem(__pyx_v_registries, __pyx_mstate_global->__pyx_int_neg_1, __pyx_v_shared) < 0))) __PYX_ERR(2, 1996, __pyx_L1_error)

+1997:             if shared.accepts(cats):

      __pyx_t_1 = __pyx_v_shared;
      __Pyx_INCREF(__pyx_t_1);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_cats};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_accepts, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1997, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 1997, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_8) {
/* … */
        goto __pyx_L18;
      }

+1998:                 reg = shared

        __Pyx_INCREF(__pyx_v_shared);
        __Pyx_XDECREF_SET(__pyx_v_reg, __pyx_v_shared);

 1999:             else:

+2000:                 reg = registries.get(i)

      /*else*/ {
        if (unlikely(__pyx_v_registries == Py_None)) {
          PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get");
          __PYX_ERR(2, 2000, __pyx_L1_error)
        }
        __pyx_t_4 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2000, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_1 = __Pyx_PyDict_GetItemDefault(__pyx_v_registries, __pyx_t_4, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2000, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF_SET(__pyx_v_reg, __pyx_t_1);
        __pyx_t_1 = 0;

+2001:                 if reg is None:

        __pyx_t_8 = (__pyx_v_reg == Py_None);
        if (__pyx_t_8) {
/* … */
        }
      }
      __pyx_L18:;

+2002:                     reg = _PolarsSymbolRegistry(pl)

          __pyx_t_4 = NULL;
          __pyx_t_7 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_pl};
            __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_7questdb_7_client__PolarsSymbolRegistry, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2002, __pyx_L1_error)
            __Pyx_GOTREF((PyObject *)__pyx_t_1);
          }
          __Pyx_DECREF_SET(__pyx_v_reg, ((PyObject *)__pyx_t_1));
          __pyx_t_1 = 0;

+2003:                     registries[i] = reg

          if (unlikely(__pyx_v_registries == Py_None)) {
            PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
            __PYX_ERR(2, 2003, __pyx_L1_error)
          }
          __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2003, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          if (unlikely((PyDict_SetItem(__pyx_v_registries, __pyx_t_1, __pyx_v_reg) < 0))) __PYX_ERR(2, 2003, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2004:             cols.append(reg.column(names[i], codes, cats))

      __pyx_t_4 = __pyx_v_reg;
      __Pyx_INCREF(__pyx_t_4);
      if (unlikely(__pyx_v_names == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
        __PYX_ERR(2, 2004, __pyx_L1_error)
      }
      __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_names, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2004, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_t_2, __pyx_v_codes, __pyx_v_cats};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_column_2, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2004, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_cols, __pyx_t_1); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 2004, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 2005:         else:

+2006:             cols.append(nd.get_column(names[i]))

    /*else*/ {
      __pyx_t_2 = __pyx_v_nd;
      __Pyx_INCREF(__pyx_t_2);
      if (unlikely(__pyx_v_names == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
        __PYX_ERR(2, 2006, __pyx_L1_error)
      }
      __pyx_t_4 = __Pyx_GetItemInt_List(__pyx_v_names, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2006, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_7 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
        __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_column, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2006, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_cols, __pyx_t_1); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 2006, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    }
    __pyx_L16:;
  }

+2007:     return pl.DataFrame(cols)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __pyx_v_pl;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_7 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_cols};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_DataFrame, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2007, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 2008: 

 2009: 

+2010: cdef class _PolarsBatchIter:

struct __pyx_obj_7questdb_7_client__PolarsBatchIter {
  PyObject_HEAD
  PyObject *reader;
  PyObject *pl;
  PyObject *pa;
  PyObject *registries;
  int use_hybrid;
};

 2011:     """Streaming `polars.DataFrame` per result batch. Holds the per-symbol

 2012:     `Categories` registries so every batch's Categoricals share one identity

 2013:     and `pl.concat` stitches cleanly."""

 2014:     cdef object reader

 2015:     cdef object pl

 2016:     cdef object pa

 2017:     cdef dict registries

 2018:     cdef bint use_hybrid

 2019: 

+2020:     def __cinit__(self, _CursorHandle handle, object pl, object pa):

/* Python wrapper */
static int __pyx_pw_7questdb_7_client_16_PolarsBatchIter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_7questdb_7_client_16_PolarsBatchIter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle = 0;
  PyObject *__pyx_v_pl = 0;
  PyObject *__pyx_v_pa = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_handle,&__pyx_mstate_global->__pyx_n_u_pl,&__pyx_mstate_global->__pyx_n_u_pa,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2020, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 2020, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2020, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2020, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(2, 2020, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, i); __PYX_ERR(2, 2020, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2020, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2020, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 2020, __pyx_L3_error)
    }
    __pyx_v_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)values[0]);
    __pyx_v_pl = values[1];
    __pyx_v_pa = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 2020, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client._PolarsBatchIter.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handle), __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle, 1, "handle", 0))) __PYX_ERR(2, 2020, __pyx_L1_error)
  __pyx_r = __pyx_pf_7questdb_7_client_16_PolarsBatchIter___cinit__(((struct __pyx_obj_7questdb_7_client__PolarsBatchIter *)__pyx_v_self), __pyx_v_handle, __pyx_v_pl, __pyx_v_pa);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_7questdb_7_client_16_PolarsBatchIter___cinit__(struct __pyx_obj_7questdb_7_client__PolarsBatchIter *__pyx_v_self, struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle, PyObject *__pyx_v_pl, PyObject *__pyx_v_pa) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("questdb._client._PolarsBatchIter.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+2021:         self.reader = _build_record_batch_reader(handle)

  __pyx_t_1 = __pyx_f_7questdb_7_client__build_record_batch_reader(__pyx_v_handle, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2021, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->reader);
  __Pyx_DECREF(__pyx_v_self->reader);
  __pyx_v_self->reader = __pyx_t_1;
  __pyx_t_1 = 0;

+2022:         self.pl = pl

  __Pyx_INCREF(__pyx_v_pl);
  __Pyx_GIVEREF(__pyx_v_pl);
  __Pyx_GOTREF(__pyx_v_self->pl);
  __Pyx_DECREF(__pyx_v_self->pl);
  __pyx_v_self->pl = __pyx_v_pl;

+2023:         self.pa = pa

  __Pyx_INCREF(__pyx_v_pa);
  __Pyx_GIVEREF(__pyx_v_pa);
  __Pyx_GOTREF(__pyx_v_self->pa);
  __Pyx_DECREF(__pyx_v_self->pa);
  __pyx_v_self->pa = __pyx_v_pa;

+2024:         self.registries = {}

  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2024, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->registries);
  __Pyx_DECREF(__pyx_v_self->registries);
  __pyx_v_self->registries = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2025:         self.use_hybrid = getattr(pl, 'Categories', None) is not None

  __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_pl, __pyx_mstate_global->__pyx_n_u_Categories, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2025, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__pyx_t_1 != Py_None);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_self->use_hybrid = __pyx_t_2;

 2026: 

+2027:     def __iter__(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_16_PolarsBatchIter_3__iter__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_7questdb_7_client_16_PolarsBatchIter_3__iter__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_7questdb_7_client_16_PolarsBatchIter_2__iter__(((struct __pyx_obj_7questdb_7_client__PolarsBatchIter *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_16_PolarsBatchIter_2__iter__(struct __pyx_obj_7questdb_7_client__PolarsBatchIter *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+2028:         return self

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_self);
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

 2029: 

+2030:     def __next__(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_16_PolarsBatchIter_5__next__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_7questdb_7_client_16_PolarsBatchIter_5__next__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_7questdb_7_client_16_PolarsBatchIter_4__next__(((struct __pyx_obj_7questdb_7_client__PolarsBatchIter *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_16_PolarsBatchIter_4__next__(struct __pyx_obj_7questdb_7_client__PolarsBatchIter *__pyx_v_self) {
  PyObject *__pyx_v_batch = NULL;
  PyObject *__pyx_v_table = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("questdb._client._PolarsBatchIter.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_batch);
  __Pyx_XDECREF(__pyx_v_table);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+2031:         batch = next(self.reader)

  __pyx_t_1 = __pyx_v_self->reader;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyIter_Next(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2031, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_batch = __pyx_t_2;
  __pyx_t_2 = 0;

+2032:         table = self.pa.Table.from_batches([batch])

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->pa, __pyx_mstate_global->__pyx_n_u_Table); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2032, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __pyx_t_3;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2032, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_v_batch);
  __Pyx_GIVEREF(__pyx_v_batch);
  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_v_batch) != (0)) __PYX_ERR(2, 2032, __pyx_L1_error);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4};
    __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_batches, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2032, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_v_table = __pyx_t_2;
  __pyx_t_2 = 0;

+2033:         if not self.use_hybrid:

  __pyx_t_6 = (!__pyx_v_self->use_hybrid);
  if (__pyx_t_6) {
/* … */
  }

+2034:             return self.pl.from_arrow(table)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __pyx_v_self->pl;
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_table};
      __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2034, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

+2035:         try:

  {
    /*try:*/ {
/* … */
    }
    __pyx_L4_error:;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
    __pyx_L6_except_error:;
    __Pyx_XGIVEREF(__pyx_t_7);
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_XGIVEREF(__pyx_t_9);
    __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
    goto __pyx_L1_error;
    __pyx_L8_try_return:;
    __Pyx_XGIVEREF(__pyx_t_7);
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_XGIVEREF(__pyx_t_9);
    __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
    goto __pyx_L0;
    __pyx_L7_except_return:;
    __Pyx_XGIVEREF(__pyx_t_7);
    __Pyx_XGIVEREF(__pyx_t_8);
    __Pyx_XGIVEREF(__pyx_t_9);
    __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
    goto __pyx_L0;
  }

+2036:             return _polars_dataframe_hybrid(

      __Pyx_XDECREF(__pyx_r);
/* … */
      __pyx_t_1 = __pyx_f_7questdb_7_client__polars_dataframe_hybrid(__pyx_v_table, __pyx_t_2, __pyx_t_3, ((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2036, __pyx_L4_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_r = __pyx_t_1;
      __pyx_t_1 = 0;
      goto __pyx_L8_try_return;

+2037:                 table, self.pl, self.pa, self.registries)

      __pyx_t_2 = __pyx_v_self->pl;
      __Pyx_INCREF(__pyx_t_2);
      __pyx_t_3 = __pyx_v_self->pa;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_4 = __pyx_v_self->registries;
      __Pyx_INCREF(__pyx_t_4);

+2038:         except Exception:

    __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
    if (__pyx_t_10) {
      __Pyx_AddTraceback("questdb._client._PolarsBatchIter.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_3) < 0) __PYX_ERR(2, 2038, __pyx_L6_except_error)
      __Pyx_XGOTREF(__pyx_t_1);
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_XGOTREF(__pyx_t_3);

+2039:             return self.pl.from_arrow(table)

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_11 = __pyx_v_self->pl;
      __Pyx_INCREF(__pyx_t_11);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_v_table};
        __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2039, __pyx_L6_except_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_r = __pyx_t_2;
      __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      goto __pyx_L7_except_return;
    }
    goto __pyx_L6_except_error;

 2040: 

 2041: 

+2042: cdef class _NumpyBatchIter:

struct __pyx_obj_7questdb_7_client__NumpyBatchIter {
  PyObject_HEAD
  struct __pyx_obj_7questdb_7_client__CursorHandle *handle;
  PyObject *np;
  PyObject *pd;
  PyObject *col_names;
  PyObject *col_kinds;
  PyObject *col_scales;
  PyObject *col_precision;
  int first;
  int has_symbol;
  int done;
  size_t prev_dict_n;
  PyObject *symbol_categories;
  PyObject *symbol_dtype;
  int seen_seq;
  int delivered;
};

 2043:     cdef _CursorHandle handle

 2044:     cdef object np

 2045:     cdef object pd

 2046:     cdef list col_names

 2047:     cdef list col_kinds

 2048:     cdef list col_scales

 2049:     cdef list col_precision

 2050:     cdef bint first

 2051:     cdef bint has_symbol

 2052:     cdef bint done

 2053:     cdef size_t prev_dict_n

 2054:     cdef list symbol_categories

 2055:     cdef object symbol_dtype

 2056:     cdef int seen_seq

 2057:     cdef bint delivered

 2058: 

+2059:     def __cinit__(self, _CursorHandle handle):

/* Python wrapper */
static int __pyx_pw_7questdb_7_client_15_NumpyBatchIter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_7questdb_7_client_15_NumpyBatchIter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
  #endif
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_handle,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2059, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2059, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(2, 2059, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, i); __PYX_ERR(2, 2059, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2059, __pyx_L3_error)
    }
    __pyx_v_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2059, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client._NumpyBatchIter.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_handle), __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle, 1, "handle", 0))) __PYX_ERR(2, 2059, __pyx_L1_error)
  __pyx_r = __pyx_pf_7questdb_7_client_15_NumpyBatchIter___cinit__(((struct __pyx_obj_7questdb_7_client__NumpyBatchIter *)__pyx_v_self), __pyx_v_handle);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = -1;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_7questdb_7_client_15_NumpyBatchIter___cinit__(struct __pyx_obj_7questdb_7_client__NumpyBatchIter *__pyx_v_self, struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle) {
  PyObject *__pyx_v_np = NULL;
  PyObject *__pyx_v_pd = NULL;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("questdb._client._NumpyBatchIter.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_np);
  __Pyx_XDECREF(__pyx_v_pd);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+2060:         import numpy as np

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2060, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_np = __pyx_t_1;
  __pyx_t_1 = 0;

+2061:         import pandas as pd

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pandas, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2061, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_pd = __pyx_t_1;
  __pyx_t_1 = 0;

+2062:         self.handle = handle

  __Pyx_INCREF((PyObject *)__pyx_v_handle);
  __Pyx_GIVEREF((PyObject *)__pyx_v_handle);
  __Pyx_GOTREF((PyObject *)__pyx_v_self->handle);
  __Pyx_DECREF((PyObject *)__pyx_v_self->handle);
  __pyx_v_self->handle = __pyx_v_handle;

+2063:         self.np = np

  __Pyx_INCREF(__pyx_v_np);
  __Pyx_GIVEREF(__pyx_v_np);
  __Pyx_GOTREF(__pyx_v_self->np);
  __Pyx_DECREF(__pyx_v_self->np);
  __pyx_v_self->np = __pyx_v_np;

+2064:         self.pd = pd

  __Pyx_INCREF(__pyx_v_pd);
  __Pyx_GIVEREF(__pyx_v_pd);
  __Pyx_GOTREF(__pyx_v_self->pd);
  __Pyx_DECREF(__pyx_v_self->pd);
  __pyx_v_self->pd = __pyx_v_pd;

+2065:         self.col_names = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2065, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->col_names);
  __Pyx_DECREF(__pyx_v_self->col_names);
  __pyx_v_self->col_names = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2066:         self.col_kinds = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2066, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->col_kinds);
  __Pyx_DECREF(__pyx_v_self->col_kinds);
  __pyx_v_self->col_kinds = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2067:         self.col_scales = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2067, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->col_scales);
  __Pyx_DECREF(__pyx_v_self->col_scales);
  __pyx_v_self->col_scales = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2068:         self.col_precision = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2068, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->col_precision);
  __Pyx_DECREF(__pyx_v_self->col_precision);
  __pyx_v_self->col_precision = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2069:         self.first = True

  __pyx_v_self->first = 1;

+2070:         self.has_symbol = False

  __pyx_v_self->has_symbol = 0;

+2071:         self.done = False

  __pyx_v_self->done = 0;

+2072:         self.prev_dict_n = 0

  __pyx_v_self->prev_dict_n = 0;

+2073:         self.symbol_categories = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->symbol_categories);
  __Pyx_DECREF(__pyx_v_self->symbol_categories);
  __pyx_v_self->symbol_categories = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2074:         self.symbol_dtype = None

  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  __Pyx_GOTREF(__pyx_v_self->symbol_dtype);
  __Pyx_DECREF(__pyx_v_self->symbol_dtype);
  __pyx_v_self->symbol_dtype = Py_None;

+2075:         self.seen_seq = handle._reset_seq if handle is not None else 0

  __pyx_t_4 = (((PyObject *)__pyx_v_handle) != Py_None);
  if (__pyx_t_4) {
    __pyx_t_3 = __pyx_v_handle->_reset_seq;
  } else {
    __pyx_t_3 = 0;
  }
  __pyx_v_self->seen_seq = __pyx_t_3;

+2076:         self.delivered = False

  __pyx_v_self->delivered = 0;

 2077: 

+2078:     def __iter__(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_15_NumpyBatchIter_3__iter__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_7questdb_7_client_15_NumpyBatchIter_3__iter__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_7questdb_7_client_15_NumpyBatchIter_2__iter__(((struct __pyx_obj_7questdb_7_client__NumpyBatchIter *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_15_NumpyBatchIter_2__iter__(struct __pyx_obj_7questdb_7_client__NumpyBatchIter *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+2079:         return self

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF((PyObject *)__pyx_v_self);
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

 2080: 

+2081:     def __next__(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_15_NumpyBatchIter_5__next__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_7questdb_7_client_15_NumpyBatchIter_5__next__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_7questdb_7_client_15_NumpyBatchIter_4__next__(((struct __pyx_obj_7questdb_7_client__NumpyBatchIter *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_15_NumpyBatchIter_4__next__(struct __pyx_obj_7questdb_7_client__NumpyBatchIter *__pyx_v_self) {
  struct qwp_reader_cursor *__pyx_v_cursor;
  questdb_error *__pyx_v_err;
  struct qwp_reader_batch const *__pyx_v_batch;
  struct qwp_reader_symbol_dict __pyx_v_sd;
  size_t __pyx_v_row_count;
  size_t __pyx_v_n_cols;
  PyObject *__pyx_v_batch_chunks = NULL;
  PyObject *__pyx_v_batch_masks = NULL;
  PyObject *__pyx_v_col_chunks = NULL;
  PyObject *__pyx_v_col_masks = NULL;
  PyObject *__pyx_v_frame = NULL;
  PyObject *__pyx_8genexpr8__pyx_v_c = NULL;
  PyObject *__pyx_8genexpr9__pyx_v_m = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_XDECREF(__pyx_t_16);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_22);
  __Pyx_XDECREF(__pyx_t_23);
  __Pyx_XDECREF(__pyx_t_24);
  if (!__pyx_error_without_exception) {
    __Pyx_AddTraceback("questdb._client._NumpyBatchIter.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_batch_chunks);
  __Pyx_XDECREF(__pyx_v_batch_masks);
  __Pyx_XDECREF(__pyx_v_col_chunks);
  __Pyx_XDECREF(__pyx_v_col_masks);
  __Pyx_XDECREF(__pyx_v_frame);
  __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_c);
  __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_m);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 2082:         cdef qwp_reader_cursor* cursor

+2083:         cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 2084:         cdef const qwp_reader_batch* batch

 2085:         cdef qwp_reader_symbol_dict sd

 2086:         cdef size_t row_count

 2087:         cdef size_t n_cols

+2088:         if self.done or self.handle is None or self.handle._cursor == NULL:

  if (!__pyx_v_self->done) {
  } else {
    __pyx_t_1 = __pyx_v_self->done;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (((PyObject *)__pyx_v_self->handle) == Py_None);
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_self->handle->_cursor == NULL);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+2089:             raise StopIteration

    __pyx_error_without_exception = 1;
    goto __pyx_L1_error;;

+2090:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L12_try_end;
    __pyx_L7_error:;
    __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
    __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
    __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
    __pyx_L9_except_error:;
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_XGIVEREF(__pyx_t_4);
    __Pyx_XGIVEREF(__pyx_t_5);
    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
    goto __pyx_L1_error;
    __pyx_L12_try_end:;
  }

+2091:             with self.handle._lock:

      /*with:*/ {
        __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->handle->_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2091, __pyx_L7_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_8 = NULL;
        __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->handle->_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2091, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_9);
        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (likely(PyMethod_Check(__pyx_t_9))) {
          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9);
          assert(__pyx_t_8);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
          __Pyx_INCREF(__pyx_t_8);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL};
          __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_9, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2091, __pyx_L13_error)
          __Pyx_GOTREF(__pyx_t_7);
        }
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        /*try:*/ {
          {
            /*try:*/ {
/* … */
            }
            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
            __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            goto __pyx_L22_try_end;
            __pyx_L17_error:;
            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
            __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
            __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
            /*except:*/ {
              __Pyx_AddTraceback("questdb._client._NumpyBatchIter.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
              if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_7, &__pyx_t_18) < 0) __PYX_ERR(2, 2091, __pyx_L19_except_error)
              __Pyx_XGOTREF(__pyx_t_9);
              __Pyx_XGOTREF(__pyx_t_7);
              __Pyx_XGOTREF(__pyx_t_18);
              __pyx_t_8 = PyTuple_Pack(3, __pyx_t_9, __pyx_t_7, __pyx_t_18); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2091, __pyx_L19_except_error)
              __Pyx_GOTREF(__pyx_t_8);
              __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL);
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 2091, __pyx_L19_except_error)
              __Pyx_GOTREF(__pyx_t_20);
              __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_20);
              __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
              if (__pyx_t_1 < (0)) __PYX_ERR(2, 2091, __pyx_L19_except_error)
              __pyx_t_2 = (!__pyx_t_1);
              if (unlikely(__pyx_t_2)) {
                __Pyx_GIVEREF(__pyx_t_9);
                __Pyx_GIVEREF(__pyx_t_7);
                __Pyx_XGIVEREF(__pyx_t_18);
                __Pyx_ErrRestoreWithState(__pyx_t_9, __pyx_t_7, __pyx_t_18);
                __pyx_t_9 = 0;  __pyx_t_7 = 0;  __pyx_t_18 = 0; 
                __PYX_ERR(2, 2091, __pyx_L19_except_error)
              }
              __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
              goto __pyx_L18_exception_handled;
            }
            __pyx_L19_except_error:;
            __Pyx_XGIVEREF(__pyx_t_11);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_XGIVEREF(__pyx_t_13);
            __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
            goto __pyx_L7_error;
            __pyx_L18_exception_handled:;
            __Pyx_XGIVEREF(__pyx_t_11);
            __Pyx_XGIVEREF(__pyx_t_12);
            __Pyx_XGIVEREF(__pyx_t_13);
            __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
            __pyx_L22_try_end:;
          }
        }
        /*finally:*/ {
          /*normal exit:*/{
            if (__pyx_t_6) {
              __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[2], NULL);
              __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
              if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 2091, __pyx_L7_error)
              __Pyx_GOTREF(__pyx_t_13);
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            }
            goto __pyx_L16;
          }
          __pyx_L16:;
        }
        goto __pyx_L37;
        __pyx_L13_error:;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        goto __pyx_L7_error;
        __pyx_L37:;
      }

+2092:                 cursor = self.handle._cursor

              __pyx_t_14 = __pyx_v_self->handle->_cursor;
              __pyx_v_cursor = __pyx_t_14;

+2093:                 if cursor == NULL:

              __pyx_t_1 = (__pyx_v_cursor == NULL);
              if (unlikely(__pyx_t_1)) {
/* … */
              }

+2094:                     raise QuestDBError(

                __pyx_t_9 = NULL;
                __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2094, __pyx_L17_error)
                __Pyx_GOTREF(__pyx_t_8);

+2095:                         QuestDBErrorCode.InvalidApiCall, 'cursor is closed')

                __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2095, __pyx_L17_error)
                __Pyx_GOTREF(__pyx_t_15);
                __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 2095, __pyx_L17_error)
                __Pyx_GOTREF(__pyx_t_16);
                __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                __pyx_t_10 = 1;
                #if CYTHON_UNPACK_METHODS
                if (unlikely(PyMethod_Check(__pyx_t_8))) {
                  __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
                  assert(__pyx_t_9);
                  PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
                  __Pyx_INCREF(__pyx_t_9);
                  __Pyx_INCREF(__pyx__function);
                  __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
                  __pyx_t_10 = 0;
                }
                #endif
                {
                  PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_16, __pyx_mstate_global->__pyx_kp_u_cursor_is_closed};
                  __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
                  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
                  if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2094, __pyx_L17_error)
                  __Pyx_GOTREF(__pyx_t_7);
                }
                __Pyx_Raise(__pyx_t_7, 0, 0, 0);
                __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
                __PYX_ERR(2, 2094, __pyx_L17_error)

+2096:                 with nogil:

              {
                  PyThreadState * _save;
                  _save = PyEval_SaveThread();
                  __Pyx_FastGIL_Remember();
                  /*try:*/ {
/* … */
                  /*finally:*/ {
                    /*normal exit:*/{
                      __Pyx_FastGIL_Forget();
                      PyEval_RestoreThread(_save);
                      goto __pyx_L26;
                    }
                    __pyx_L26:;
                  }
              }

+2097:                     batch = qwp_reader_cursor_next_batch(cursor, &err)

                    __pyx_v_batch = qwp_reader_cursor_next_batch(__pyx_v_cursor, (&__pyx_v_err));
                  }

+2098:                 if self.handle._reset_seq != self.seen_seq:

              __pyx_t_1 = (__pyx_v_self->handle->_reset_seq != __pyx_v_self->seen_seq);
              if (__pyx_t_1) {
/* … */
              }

+2099:                     if self.delivered:

                if (unlikely(__pyx_v_self->delivered)) {
/* … */
                }

 2100:                         # Mid-query failover after batches were already yielded:

 2101:                         # the replayed batch-0 would duplicate them. Streaming

 2102:                         # can't discard it, so surface a clean, catchable error.

+2103:                         self.done = True

                  __pyx_v_self->done = 1;

+2104:                         raise QuestDBError(

                  __pyx_t_8 = NULL;
                  __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 2104, __pyx_L17_error)
                  __Pyx_GOTREF(__pyx_t_16);

+2105:                             QuestDBErrorCode.FailoverWouldDuplicate,

                  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2105, __pyx_L17_error)
                  __Pyx_GOTREF(__pyx_t_9);
                  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_FailoverWouldDuplicate); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2105, __pyx_L17_error)
                  __Pyx_GOTREF(__pyx_t_15);
                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
                  __pyx_t_10 = 1;
                  #if CYTHON_UNPACK_METHODS
                  if (unlikely(PyMethod_Check(__pyx_t_16))) {
                    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_16);
                    assert(__pyx_t_8);
                    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_16);
                    __Pyx_INCREF(__pyx_t_8);
                    __Pyx_INCREF(__pyx__function);
                    __Pyx_DECREF_SET(__pyx_t_16, __pyx__function);
                    __pyx_t_10 = 0;
                  }
                  #endif
                  {
                    PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_15, __pyx_mstate_global->__pyx_kp_u_mid_query_failover_would_duplica};
                    __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_16, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
                    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
                    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
                    if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2104, __pyx_L17_error)
                    __Pyx_GOTREF(__pyx_t_7);
                  }
                  __Pyx_Raise(__pyx_t_7, 0, 0, 0);
                  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
                  __PYX_ERR(2, 2104, __pyx_L17_error)

 2106:                             'mid-query failover would duplicate already-'

 2107:                             'delivered batches; re-issue the query')

 2108:                     # Pre-delivery failover replays batch-0 transparently:

 2109:                     # re-pin to the new stream and drop the accumulated

 2110:                     # schema and symbol dictionary. The replayed stream

 2111:                     # restarts its query-scoped dictionary at entry 0, so

 2112:                     # its codes only decode against categories rebuilt

 2113:                     # from that stream.

+2114:                     self.seen_seq = self.handle._reset_seq

                __pyx_t_17 = __pyx_v_self->handle->_reset_seq;
                __pyx_v_self->seen_seq = __pyx_t_17;

+2115:                     self.first = True

                __pyx_v_self->first = 1;

+2116:                     self.has_symbol = False

                __pyx_v_self->has_symbol = 0;

+2117:                     self.prev_dict_n = 0

                __pyx_v_self->prev_dict_n = 0;

+2118:                     self.symbol_categories = []

                __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2118, __pyx_L17_error)
                __Pyx_GOTREF(__pyx_t_7);
                __Pyx_GIVEREF(__pyx_t_7);
                __Pyx_GOTREF(__pyx_v_self->symbol_categories);
                __Pyx_DECREF(__pyx_v_self->symbol_categories);
                __pyx_v_self->symbol_categories = ((PyObject*)__pyx_t_7);
                __pyx_t_7 = 0;

+2119:                     self.symbol_dtype = None

                __Pyx_INCREF(Py_None);
                __Pyx_GIVEREF(Py_None);
                __Pyx_GOTREF(__pyx_v_self->symbol_dtype);
                __Pyx_DECREF(__pyx_v_self->symbol_dtype);
                __pyx_v_self->symbol_dtype = Py_None;

+2120:                 if batch == NULL:

              __pyx_t_1 = (__pyx_v_batch == NULL);
              if (__pyx_t_1) {
/* … */
              }

+2121:                     self.done = True

                __pyx_v_self->done = 1;

+2122:                     if err != NULL:

                __pyx_t_1 = (__pyx_v_err != NULL);
                if (unlikely(__pyx_t_1)) {
/* … */
                }

+2123:                         raise _reader_err_to_py(err)

                  __pyx_t_7 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2123, __pyx_L17_error)
                  __Pyx_GOTREF(__pyx_t_7);
                  __Pyx_Raise(__pyx_t_7, 0, 0, 0);
                  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
                  __PYX_ERR(2, 2123, __pyx_L17_error)

+2124:                     _mark_reader_drained(self.handle)

                __pyx_t_7 = ((PyObject *)__pyx_v_self->handle);
                __Pyx_INCREF(__pyx_t_7);
                __pyx_f_7questdb_7_client__mark_reader_drained(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_7));
                __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+2125:                     raise StopIteration

                __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_StopIteration))), 0, 0, 0);
                __PYX_ERR(2, 2125, __pyx_L17_error)

+2126:                 row_count = qwp_reader_batch_row_count(batch)

              __pyx_v_row_count = qwp_reader_batch_row_count(__pyx_v_batch);

+2127:                 if self.first:

              if (__pyx_v_self->first) {
/* … */
              }

+2128:                     (self.col_names, self.col_kinds, self.col_scales,

                if (!(likely(PyList_CheckExact(__pyx_t_16))||((__pyx_t_16) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_16))) __PYX_ERR(2, 2128, __pyx_L17_error)
                if (!(likely(PyList_CheckExact(__pyx_t_15))||((__pyx_t_15) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_15))) __PYX_ERR(2, 2128, __pyx_L17_error)
                if (!(likely(PyList_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_8))) __PYX_ERR(2, 2128, __pyx_L17_error)
                if (!(likely(PyList_CheckExact(__pyx_t_9))||((__pyx_t_9) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_9))) __PYX_ERR(2, 2128, __pyx_L17_error)
                __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 2128, __pyx_L17_error)
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __Pyx_GIVEREF(__pyx_t_16);
                __Pyx_GOTREF(__pyx_v_self->col_names);
                __Pyx_DECREF(__pyx_v_self->col_names);
                __pyx_v_self->col_names = ((PyObject*)__pyx_t_16);
                __pyx_t_16 = 0;
                __Pyx_GIVEREF(__pyx_t_15);
                __Pyx_GOTREF(__pyx_v_self->col_kinds);
                __Pyx_DECREF(__pyx_v_self->col_kinds);
                __pyx_v_self->col_kinds = ((PyObject*)__pyx_t_15);
                __pyx_t_15 = 0;
                __Pyx_GIVEREF(__pyx_t_8);
                __Pyx_GOTREF(__pyx_v_self->col_scales);
                __Pyx_DECREF(__pyx_v_self->col_scales);
                __pyx_v_self->col_scales = ((PyObject*)__pyx_t_8);
                __pyx_t_8 = 0;

+2129:                      self.col_precision, self.has_symbol) = \

                __Pyx_GIVEREF(__pyx_t_9);
                __Pyx_GOTREF(__pyx_v_self->col_precision);
                __Pyx_DECREF(__pyx_v_self->col_precision);
                __pyx_v_self->col_precision = ((PyObject*)__pyx_t_9);
                __pyx_t_9 = 0;
                __pyx_v_self->has_symbol = __pyx_t_1;

+2130:                         _numpy_extract_meta(batch)

                __pyx_t_7 = __pyx_f_7questdb_7_client__numpy_extract_meta(__pyx_v_batch); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2130, __pyx_L17_error)
                __Pyx_GOTREF(__pyx_t_7);
                if (likely(__pyx_t_7 != Py_None)) {
                  PyObject* sequence = __pyx_t_7;
                  Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
                  if (unlikely(size != 5)) {
                    if (size > 5) __Pyx_RaiseTooManyValuesError(5);
                    else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                    __PYX_ERR(2, 2128, __pyx_L17_error)
                  }
                  #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                  __pyx_t_16 = PyTuple_GET_ITEM(sequence, 0);
                  __Pyx_INCREF(__pyx_t_16);
                  __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1);
                  __Pyx_INCREF(__pyx_t_15);
                  __pyx_t_8 = PyTuple_GET_ITEM(sequence, 2);
                  __Pyx_INCREF(__pyx_t_8);
                  __pyx_t_9 = PyTuple_GET_ITEM(sequence, 3);
                  __Pyx_INCREF(__pyx_t_9);
                  __pyx_t_18 = PyTuple_GET_ITEM(sequence, 4);
                  __Pyx_INCREF(__pyx_t_18);
                  #else
                  {
                    Py_ssize_t i;
                    PyObject** temps[5] = {&__pyx_t_16,&__pyx_t_15,&__pyx_t_8,&__pyx_t_9,&__pyx_t_18};
                    for (i=0; i < 5; i++) {
                      PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(2, 2128, __pyx_L17_error)
                      __Pyx_GOTREF(item);
                      *(temps[i]) = item;
                    }
                  }
                  #endif
                  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
                } else {
                  __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 2128, __pyx_L17_error)
                }

+2131:                     self.first = False

                __pyx_v_self->first = 0;

+2132:                 n_cols = <size_t>len(self.col_names)

              __pyx_t_7 = __pyx_v_self->col_names;
              __Pyx_INCREF(__pyx_t_7);
              if (unlikely(__pyx_t_7 == Py_None)) {
                PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
                __PYX_ERR(2, 2132, __pyx_L17_error)
              }
              __pyx_t_19 = __Pyx_PyList_GET_SIZE(__pyx_t_7); if (unlikely(__pyx_t_19 == ((Py_ssize_t)-1))) __PYX_ERR(2, 2132, __pyx_L17_error)
              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
              __pyx_v_n_cols = ((size_t)__pyx_t_19);

+2133:                 if self.has_symbol:

              if (__pyx_v_self->has_symbol) {
/* … */
              }

+2134:                     _reader_check(

                __pyx_t_17 = __pyx_f_7questdb_7_client__reader_check(qwp_reader_batch_symbol_dict(__pyx_v_batch, (&__pyx_v_sd), (&__pyx_v_err)), (&__pyx_v_err), __pyx_mstate_global->__pyx_n_u_qwp_reader_batch_symbol_dict); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(2, 2134, __pyx_L17_error)

 2135:                         qwp_reader_batch_symbol_dict(batch, &sd, &err), &err,

 2136:                         'qwp_reader_batch_symbol_dict')

+2137:                     if sd.entry_count > self.prev_dict_n:

                __pyx_t_1 = (__pyx_v_sd.entry_count > __pyx_v_self->prev_dict_n);
                if (__pyx_t_1) {
/* … */
                }

+2138:                         _symbol_categories_extend(

                  __pyx_f_7questdb_7_client__symbol_categories_extend(((PyObject*)__pyx_t_7), (&__pyx_v_sd), __pyx_v_self->prev_dict_n); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 2138, __pyx_L17_error)
                  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

+2139:                             self.symbol_categories, &sd, self.prev_dict_n)

                  __pyx_t_7 = __pyx_v_self->symbol_categories;
                  __Pyx_INCREF(__pyx_t_7);

+2140:                         self.symbol_dtype = self.pd.CategoricalDtype(

                  __pyx_t_18 = __pyx_v_self->pd;
                  __Pyx_INCREF(__pyx_t_18);
/* … */
                  __Pyx_GIVEREF(__pyx_t_7);
                  __Pyx_GOTREF(__pyx_v_self->symbol_dtype);
                  __Pyx_DECREF(__pyx_v_self->symbol_dtype);
                  __pyx_v_self->symbol_dtype = __pyx_t_7;
                  __pyx_t_7 = 0;

+2141:                             self.symbol_categories)

                  __pyx_t_10 = 0;
                  {
                    PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_v_self->symbol_categories};
                    __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_CategoricalDtype, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                    __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
                    if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2140, __pyx_L17_error)
                    __Pyx_GOTREF(__pyx_t_7);
                  }

+2142:                         self.prev_dict_n = sd.entry_count

                  __pyx_t_10 = __pyx_v_sd.entry_count;
                  __pyx_v_self->prev_dict_n = __pyx_t_10;

+2143:                 batch_chunks, batch_masks = _numpy_batch_columns(

              __pyx_t_9 = __pyx_f_7questdb_7_client__numpy_batch_columns(__pyx_v_batch, ((PyObject*)__pyx_t_7), __pyx_v_n_cols, __pyx_v_row_count, __pyx_t_18); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2143, __pyx_L17_error)
              __Pyx_GOTREF(__pyx_t_9);
              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              if (likely(__pyx_t_9 != Py_None)) {
                PyObject* sequence = __pyx_t_9;
                Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
                if (unlikely(size != 2)) {
                  if (size > 2) __Pyx_RaiseTooManyValuesError(2);
                  else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                  __PYX_ERR(2, 2143, __pyx_L17_error)
                }
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                __pyx_t_18 = PyTuple_GET_ITEM(sequence, 0);
                __Pyx_INCREF(__pyx_t_18);
                __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
                __Pyx_INCREF(__pyx_t_7);
                #else
                __pyx_t_18 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 2143, __pyx_L17_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2143, __pyx_L17_error)
                __Pyx_GOTREF(__pyx_t_7);
                #endif
                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
              } else {
                __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 2143, __pyx_L17_error)
              }
              __pyx_v_batch_chunks = __pyx_t_18;
              __pyx_t_18 = 0;
              __pyx_v_batch_masks = __pyx_t_7;
              __pyx_t_7 = 0;

+2144:                     batch, self.col_kinds, n_cols, row_count, self.np)

              __pyx_t_7 = __pyx_v_self->col_kinds;
              __Pyx_INCREF(__pyx_t_7);
              __pyx_t_18 = __pyx_v_self->np;
              __Pyx_INCREF(__pyx_t_18);

 2145:             # Assembly needs no cursor state, so it runs off the lock —

 2146:             # but inside the try, so a failure here ends the iterator and

 2147:             # frees the cursor like every other error path. Resuming

 2148:             # after it would step onto a consumed batch carrying a

 2149:             # half-built schema.

+2150:             col_chunks = [[c] for c in batch_chunks]

      { /* enter inner scope */
        __pyx_t_18 = PyList_New(0); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 2150, __pyx_L40_error)
        __Pyx_GOTREF(__pyx_t_18);
        if (unlikely(!__pyx_v_batch_chunks)) { __Pyx_RaiseUnboundLocalError("batch_chunks"); __PYX_ERR(2, 2150, __pyx_L40_error) }
        if (likely(PyList_CheckExact(__pyx_v_batch_chunks)) || PyTuple_CheckExact(__pyx_v_batch_chunks)) {
          __pyx_t_7 = __pyx_v_batch_chunks; __Pyx_INCREF(__pyx_t_7);
          __pyx_t_19 = 0;
          __pyx_t_21 = NULL;
        } else {
          __pyx_t_19 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_batch_chunks); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2150, __pyx_L40_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_21 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_21)) __PYX_ERR(2, 2150, __pyx_L40_error)
        }
        for (;;) {
          if (likely(!__pyx_t_21)) {
            if (likely(PyList_CheckExact(__pyx_t_7))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2150, __pyx_L40_error)
                #endif
                if (__pyx_t_19 >= __pyx_temp) break;
              }
              __pyx_t_9 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_7, __pyx_t_19, __Pyx_ReferenceSharing_OwnStrongReference);
              ++__pyx_t_19;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2150, __pyx_L40_error)
                #endif
                if (__pyx_t_19 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_19));
              #else
              __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_19);
              #endif
              ++__pyx_t_19;
            }
            if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2150, __pyx_L40_error)
          } else {
            __pyx_t_9 = __pyx_t_21(__pyx_t_7);
            if (unlikely(!__pyx_t_9)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 2150, __pyx_L40_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_XDECREF_SET(__pyx_8genexpr8__pyx_v_c, __pyx_t_9);
          __pyx_t_9 = 0;
          __pyx_t_9 = PyList_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2150, __pyx_L40_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_INCREF(__pyx_8genexpr8__pyx_v_c);
          __Pyx_GIVEREF(__pyx_8genexpr8__pyx_v_c);
          if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_8genexpr8__pyx_v_c) != (0)) __PYX_ERR(2, 2150, __pyx_L40_error);
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_18, (PyObject*)__pyx_t_9))) __PYX_ERR(2, 2150, __pyx_L40_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_c); __pyx_8genexpr8__pyx_v_c = 0;
        goto __pyx_L44_exit_scope;
        __pyx_L40_error:;
        __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_c); __pyx_8genexpr8__pyx_v_c = 0;
        goto __pyx_L7_error;
        __pyx_L44_exit_scope:;
      } /* exit inner scope */
      __pyx_v_col_chunks = ((PyObject*)__pyx_t_18);
      __pyx_t_18 = 0;

+2151:             col_masks = [[m] for m in batch_masks]

      { /* enter inner scope */
        __pyx_t_18 = PyList_New(0); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 2151, __pyx_L47_error)
        __Pyx_GOTREF(__pyx_t_18);
        if (unlikely(!__pyx_v_batch_masks)) { __Pyx_RaiseUnboundLocalError("batch_masks"); __PYX_ERR(2, 2151, __pyx_L47_error) }
        if (likely(PyList_CheckExact(__pyx_v_batch_masks)) || PyTuple_CheckExact(__pyx_v_batch_masks)) {
          __pyx_t_7 = __pyx_v_batch_masks; __Pyx_INCREF(__pyx_t_7);
          __pyx_t_19 = 0;
          __pyx_t_21 = NULL;
        } else {
          __pyx_t_19 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_batch_masks); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2151, __pyx_L47_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_21 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_21)) __PYX_ERR(2, 2151, __pyx_L47_error)
        }
        for (;;) {
          if (likely(!__pyx_t_21)) {
            if (likely(PyList_CheckExact(__pyx_t_7))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2151, __pyx_L47_error)
                #endif
                if (__pyx_t_19 >= __pyx_temp) break;
              }
              __pyx_t_9 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_7, __pyx_t_19, __Pyx_ReferenceSharing_OwnStrongReference);
              ++__pyx_t_19;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2151, __pyx_L47_error)
                #endif
                if (__pyx_t_19 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_9 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_19));
              #else
              __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_19);
              #endif
              ++__pyx_t_19;
            }
            if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2151, __pyx_L47_error)
          } else {
            __pyx_t_9 = __pyx_t_21(__pyx_t_7);
            if (unlikely(!__pyx_t_9)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 2151, __pyx_L47_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_XDECREF_SET(__pyx_8genexpr9__pyx_v_m, __pyx_t_9);
          __pyx_t_9 = 0;
          __pyx_t_9 = PyList_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2151, __pyx_L47_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_INCREF(__pyx_8genexpr9__pyx_v_m);
          __Pyx_GIVEREF(__pyx_8genexpr9__pyx_v_m);
          if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_8genexpr9__pyx_v_m) != (0)) __PYX_ERR(2, 2151, __pyx_L47_error);
          if (unlikely(__Pyx_ListComp_Append(__pyx_t_18, (PyObject*)__pyx_t_9))) __PYX_ERR(2, 2151, __pyx_L47_error)
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_m); __pyx_8genexpr9__pyx_v_m = 0;
        goto __pyx_L51_exit_scope;
        __pyx_L47_error:;
        __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_m); __pyx_8genexpr9__pyx_v_m = 0;
        goto __pyx_L7_error;
        __pyx_L51_exit_scope:;
      } /* exit inner scope */
      __pyx_v_col_masks = ((PyObject*)__pyx_t_18);
      __pyx_t_18 = 0;

+2152:             frame = _numpy_assemble_frame(

      __pyx_t_25.__pyx_n = 1;
      __pyx_t_25.symbol_dtype = __pyx_t_23;
      __pyx_t_24 = __pyx_f_7questdb_7_client__numpy_assemble_frame(((PyObject*)__pyx_t_18), ((PyObject*)__pyx_t_7), ((PyObject*)__pyx_t_9), ((PyObject*)__pyx_t_8), __pyx_v_col_chunks, ((PyObject*)__pyx_t_15), __pyx_t_16, __pyx_t_22, __pyx_v_col_masks, &__pyx_t_25); if (unlikely(!__pyx_t_24)) __PYX_ERR(2, 2152, __pyx_L7_error)
      __Pyx_GOTREF(__pyx_t_24);
      __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
      __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
      __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
      __pyx_v_frame = __pyx_t_24;
      __pyx_t_24 = 0;

+2153:                 self.col_names, self.col_kinds, self.col_scales,

      __pyx_t_18 = __pyx_v_self->col_names;
      __Pyx_INCREF(__pyx_t_18);
      __pyx_t_7 = __pyx_v_self->col_kinds;
      __Pyx_INCREF(__pyx_t_7);
      __pyx_t_9 = __pyx_v_self->col_scales;
      __Pyx_INCREF(__pyx_t_9);

+2154:                 self.col_precision, col_chunks, self.symbol_categories,

      __pyx_t_8 = __pyx_v_self->col_precision;
      __Pyx_INCREF(__pyx_t_8);
      __pyx_t_15 = __pyx_v_self->symbol_categories;
      __Pyx_INCREF(__pyx_t_15);

+2155:                 self.np, self.pd, col_masks, symbol_dtype=self.symbol_dtype)

      __pyx_t_16 = __pyx_v_self->np;
      __Pyx_INCREF(__pyx_t_16);
      __pyx_t_22 = __pyx_v_self->pd;
      __Pyx_INCREF(__pyx_t_22);
      __pyx_t_23 = __pyx_v_self->symbol_dtype;
      __Pyx_INCREF(__pyx_t_23);

+2156:         except:

    /*except:*/ {
      __Pyx_AddTraceback("questdb._client._NumpyBatchIter.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_24, &__pyx_t_23, &__pyx_t_22) < 0) __PYX_ERR(2, 2156, __pyx_L9_except_error)
      __Pyx_XGOTREF(__pyx_t_24);
      __Pyx_XGOTREF(__pyx_t_23);
      __Pyx_XGOTREF(__pyx_t_22);

+2157:             self.done = True

      __pyx_v_self->done = 1;

+2158:             self.handle._free()

      ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_self->handle->__pyx_vtab)->_free(__pyx_v_self->handle);

+2159:             raise

      __Pyx_GIVEREF(__pyx_t_24);
      __Pyx_GIVEREF(__pyx_t_23);
      __Pyx_XGIVEREF(__pyx_t_22);
      __Pyx_ErrRestoreWithState(__pyx_t_24, __pyx_t_23, __pyx_t_22);
      __pyx_t_24 = 0;  __pyx_t_23 = 0;  __pyx_t_22 = 0; 
      __PYX_ERR(2, 2159, __pyx_L9_except_error)
    }

+2160:         self.delivered = True

  __pyx_v_self->delivered = 1;

+2161:         return frame

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_frame);
  __pyx_r = __pyx_v_frame;
  goto __pyx_L0;

 2162: 

+2163:     def __dealloc__(self):

/* Python wrapper */
static void __pyx_pw_7questdb_7_client_15_NumpyBatchIter_7__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_7questdb_7_client_15_NumpyBatchIter_7__dealloc__(PyObject *__pyx_v_self) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_pf_7questdb_7_client_15_NumpyBatchIter_6__dealloc__(((struct __pyx_obj_7questdb_7_client__NumpyBatchIter *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_7questdb_7_client_15_NumpyBatchIter_6__dealloc__(struct __pyx_obj_7questdb_7_client__NumpyBatchIter *__pyx_v_self) {
/* … */
  /* function exit code */
}

+2164:         if not self.done and self.handle is not None:

  __pyx_t_2 = (!__pyx_v_self->done);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (((PyObject *)__pyx_v_self->handle) != Py_None);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+2165:             self.handle._free()

    ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_self->handle->__pyx_vtab)->_free(__pyx_v_self->handle);

 2166: 

 2167: 

+2168: cdef object _resolve_arrow_to_pandas_kwargs(dtype_backend, types_mapper):

static PyObject *__pyx_f_7questdb_7_client__resolve_arrow_to_pandas_kwargs(PyObject *__pyx_v_dtype_backend, PyObject *__pyx_v_types_mapper) {
  PyObject *__pyx_v_kwargs = NULL;
  PyObject *__pyx_v_pd = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("questdb._client._resolve_arrow_to_pandas_kwargs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_kwargs);
  __Pyx_XDECREF(__pyx_v_pd);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+2169:     kwargs = {}

  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_kwargs = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+2170:     if types_mapper is not None:

  __pyx_t_2 = (__pyx_v_types_mapper != Py_None);
  if (__pyx_t_2) {
/* … */
    goto __pyx_L3;
  }

+2171:         kwargs['types_mapper'] = types_mapper

    if (unlikely((PyDict_SetItem(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_types_mapper, __pyx_v_types_mapper) < 0))) __PYX_ERR(2, 2171, __pyx_L1_error)

+2172:     elif dtype_backend == 'pyarrow':

  __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_dtype_backend, __pyx_mstate_global->__pyx_n_u_pyarrow, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 2172, __pyx_L1_error)
  if (__pyx_t_2) {
/* … */
    goto __pyx_L3;
  }

+2173:         import pandas as pd

    __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pandas, 0, 0, NULL, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2173, __pyx_L1_error)
    __pyx_t_1 = __pyx_t_3;
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_v_pd = __pyx_t_1;
    __pyx_t_1 = 0;

+2174:         kwargs['types_mapper'] = pd.ArrowDtype

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_pd, __pyx_mstate_global->__pyx_n_u_ArrowDtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2174, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (unlikely((PyDict_SetItem(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_types_mapper, __pyx_t_1) < 0))) __PYX_ERR(2, 2174, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2175:     elif dtype_backend == 'numpy_nullable':

  __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_dtype_backend, __pyx_mstate_global->__pyx_n_u_numpy_nullable, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 2175, __pyx_L1_error)
  if (__pyx_t_2) {
/* … */
    goto __pyx_L3;
  }

+2176:         kwargs['types_mapper'] = _numpy_nullable_mapping()

    __pyx_t_1 = __pyx_f_7questdb_7_client__numpy_nullable_mapping(); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2176, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (unlikely((PyDict_SetItem(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_types_mapper, __pyx_t_1) < 0))) __PYX_ERR(2, 2176, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2177:     elif dtype_backend is not None:

  __pyx_t_2 = (__pyx_v_dtype_backend != Py_None);
  if (unlikely(__pyx_t_2)) {
/* … */
  }
  __pyx_L3:;

+2178:         raise ValueError(

    __pyx_t_4 = NULL;

+2179:             f'dtype_backend={dtype_backend!r} is invalid, '

    __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_dtype_backend), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 2179, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_dtype_backend;
    __pyx_t_6[1] = __pyx_t_5;
    __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u_is_invalid_only_pyarrow_and_num;
    __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, 14 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 60, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5));
    if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2179, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_8 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2178, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 2178, __pyx_L1_error)

 2180:             'only "pyarrow" and "numpy_nullable" are allowed')

+2181:     return kwargs

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_kwargs);
  __pyx_r = __pyx_v_kwargs;
  goto __pyx_L0;

 2182: 

 2183: 

+2184: def _debug_egress_pool_stats(client):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_5_debug_egress_pool_stats(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_4_debug_egress_pool_stats, "Return ``(in_use, idle)`` from the client's reader pool.\n\n    The Rust pool doesn't track \"opened\" / \"reused\" as counters \342\200\224 they\n    fall out of ``in_use + idle`` plus the lazy-init pattern (first\n    borrow opens a connection; the idle list grows on returns; reuse\n    is implicit). Tests assert reuse by checking that ``idle == 1``\n    after sequential queries that each borrowed and returned. Returns\n    ``None`` if the QuestDB handle is closed.\n\n    Not part of the public API.\n    ");
static PyMethodDef __pyx_mdef_7questdb_7_client_5_debug_egress_pool_stats = {"_debug_egress_pool_stats", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_5_debug_egress_pool_stats, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_4_debug_egress_pool_stats};
static PyObject *__pyx_pw_7questdb_7_client_5_debug_egress_pool_stats(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_client = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_debug_egress_pool_stats (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_client,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2184, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2184, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_debug_egress_pool_stats", 0) < (0)) __PYX_ERR(2, 2184, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_debug_egress_pool_stats", 1, 1, 1, i); __PYX_ERR(2, 2184, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2184, __pyx_L3_error)
    }
    __pyx_v_client = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_debug_egress_pool_stats", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2184, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client._debug_egress_pool_stats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_4_debug_egress_pool_stats(__pyx_self, __pyx_v_client);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_4_debug_egress_pool_stats(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_client) {
  struct __pyx_obj_7questdb_7_client_QuestDB *__pyx_v_c = 0;
  struct questdb_db *__pyx_v_db;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("questdb._client._debug_egress_pool_stats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_c);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_5_debug_egress_pool_stats, 0, __pyx_mstate_global->__pyx_n_u_debug_egress_pool_stats, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2184, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4);
  #endif
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_debug_egress_pool_stats, __pyx_t_4) < (0)) __PYX_ERR(2, 2184, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2185:     """Return ``(in_use, idle)`` from the client's reader pool.

 2186: 

 2187:     The Rust pool doesn't track "opened" / "reused" as counters — they

 2188:     fall out of ``in_use + idle`` plus the lazy-init pattern (first

 2189:     borrow opens a connection; the idle list grows on returns; reuse

 2190:     is implicit). Tests assert reuse by checking that ``idle == 1``

 2191:     after sequential queries that each borrowed and returned. Returns

 2192:     ``None`` if the QuestDB handle is closed.

 2193: 

 2194:     Not part of the public API.

 2195:     """

+2196:     cdef QuestDB c = client

  __pyx_t_1 = __pyx_v_client;
  __Pyx_INCREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7questdb_7_client_QuestDB))))) __PYX_ERR(2, 2196, __pyx_L1_error)
  __pyx_v_c = ((struct __pyx_obj_7questdb_7_client_QuestDB *)__pyx_t_1);
  __pyx_t_1 = 0;

 2197:     cdef questdb_db* db

+2198:     try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_XGIVEREF(__pyx_t_4);
    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
    goto __pyx_L1_error;
    __pyx_L6_except_return:;
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_XGIVEREF(__pyx_t_4);
    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
    goto __pyx_L0;
    __pyx_L8_try_end:;
  }

+2199:         db = c._begin_db_use('_debug_egress_pool_stats')

      __pyx_t_5 = ((struct __pyx_vtabstruct_7questdb_7_client_QuestDB *)__pyx_v_c->__pyx_vtab)->_begin_db_use(__pyx_v_c, __pyx_mstate_global->__pyx_n_u_debug_egress_pool_stats); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 2199, __pyx_L3_error)
      __pyx_v_db = __pyx_t_5;

+2200:     except QuestDBError:

    __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_6, &__pyx_t_7);
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2200, __pyx_L5_except_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_8);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_ErrRestore(__pyx_t_1, __pyx_t_6, __pyx_t_7);
    __pyx_t_1 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0;
    if (__pyx_t_9) {
      __Pyx_ErrRestore(0,0,0);

+2201:         return None

      __Pyx_XDECREF(__pyx_r);
      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
      goto __pyx_L6_except_return;
    }
    goto __pyx_L5_except_error;

+2202:     try:

  /*try:*/ {

+2203:         return (

    __Pyx_XDECREF(__pyx_r);

+2204:             questdb_db_dbg_reader_in_use_count(db),

    __pyx_t_7 = __Pyx_PyLong_FromSize_t(questdb_db_dbg_reader_in_use_count(__pyx_v_db)); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2204, __pyx_L12_error)
    __Pyx_GOTREF(__pyx_t_7);
/* … */
    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2204, __pyx_L12_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_7);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_7) != (0)) __PYX_ERR(2, 2204, __pyx_L12_error);
    __Pyx_GIVEREF(__pyx_t_6);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6) != (0)) __PYX_ERR(2, 2204, __pyx_L12_error);
    __pyx_t_7 = 0;
    __pyx_t_6 = 0;
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L11_return;
  }

+2205:             questdb_db_dbg_reader_free_count(db))

    __pyx_t_6 = __Pyx_PyLong_FromSize_t(questdb_db_dbg_reader_free_count(__pyx_v_db)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2205, __pyx_L12_error)
    __Pyx_GOTREF(__pyx_t_6);

 2206:     finally:

+2207:         c._end_db_use()

  /*finally:*/ {
    __pyx_L12_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
       __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
      if ( unlikely(__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2) < 0)) __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2);
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_XGOTREF(__pyx_t_3);
      __Pyx_XGOTREF(__pyx_t_2);
      __Pyx_XGOTREF(__pyx_t_12);
      __Pyx_XGOTREF(__pyx_t_13);
      __Pyx_XGOTREF(__pyx_t_14);
      __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename;
      {
        ((struct __pyx_vtabstruct_7questdb_7_client_QuestDB *)__pyx_v_c->__pyx_vtab)->_end_db_use(__pyx_v_c); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 2207, __pyx_L15_error)
      }
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_XGIVEREF(__pyx_t_13);
      __Pyx_XGIVEREF(__pyx_t_14);
      __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
      __Pyx_XGIVEREF(__pyx_t_4);
      __Pyx_XGIVEREF(__pyx_t_3);
      __Pyx_XGIVEREF(__pyx_t_2);
      __Pyx_ErrRestore(__pyx_t_4, __pyx_t_3, __pyx_t_2);
      __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
      __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11;
      goto __pyx_L1_error;
      __pyx_L15_error:;
      __Pyx_XGIVEREF(__pyx_t_12);
      __Pyx_XGIVEREF(__pyx_t_13);
      __Pyx_XGIVEREF(__pyx_t_14);
      __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L11_return: {
      __pyx_t_14 = __pyx_r;
      __pyx_r = 0;
      ((struct __pyx_vtabstruct_7questdb_7_client_QuestDB *)__pyx_v_c->__pyx_vtab)->_end_db_use(__pyx_v_c); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 2207, __pyx_L1_error)
      __pyx_r = __pyx_t_14;
      __pyx_t_14 = 0;
      goto __pyx_L0;
    }
  }

 2208: 

 2209: 

+2210: cdef bint _cursor_handle_is_live(_CursorHandle h):

static int __pyx_f_7questdb_7_client__cursor_handle_is_live(struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_h) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

+2211:     return h is not None and h._cursor != NULL

  __pyx_t_2 = (((PyObject *)__pyx_v_h) != Py_None);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L3_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_h->_cursor != NULL);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L3_bool_binop_done:;
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

 2212: 

 2213: 

+2214: class QueryResult:

  __pyx_t_4 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_n_u_QueryResult, __pyx_mstate_global->__pyx_n_u_QueryResult, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_kp_u_Result_of_QuestDB_query_sql_Stre); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
/* … */
  __pyx_t_15 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_mstate_global->__pyx_n_u_QueryResult, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_QueryResult, __pyx_t_15) < (0)) __PYX_ERR(2, 2214, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2215:     """Result of ``QuestDB.query(sql)``.

 2216: 

 2217:     Streams query rows as Arrow record batches. **Single-use**: each

 2218:     materialisation method (``to_pandas``, ``to_arrow``, ``iter_arrow``,

 2219:     ``iter_pandas``, or the ``__arrow_c_stream__`` PyCapsule protocol)

 2220:     consumes the underlying cursor; the second consumption raises

 2221:     ``QuestDBError``.

 2222: 

 2223:     **Consumption rule**: fully drain the result, use it as a context

 2224:     manager (``with db.query(...) as result:``), or call :meth:`close`.

 2225:     Closing a partial result drops its connection. Call :meth:`cancel`

 2226:     before closing to preserve it.

 2227: 

 2228:     **Thread affinity**: the underlying cursor is bound to the thread that

 2229:     created it (via ``QuestDB.query``). Create, consume, ``cancel``,

 2230:     ``close``, and drop the ``QueryResult`` on that same thread; handing it

 2231:     to another thread is undefined behaviour even with external

 2232:     synchronisation.

 2233: 

 2234:     ``__arrow_c_stream__`` is native — the cursor's record batches are

 2235:     exposed directly through the Arrow C Data Interface, so polars /

 2236:     duckdb / pandas 3.0 / any Arrow-native consumer can read query

 2237:     results without pyarrow installed. ``to_pandas`` / ``iter_pandas``

 2238:     are also pyarrow-free by default (a native numpy path); they only

 2239:     need pyarrow when ``dtype_backend`` / ``types_mapper`` is passed.

 2240:     ``to_arrow`` / ``iter_arrow`` / ``to_polars`` / ``iter_polars``

 2241:     do require pyarrow.

 2242: 

 2243:     **SYMBOL columns**: ``to_polars`` / ``to_pandas`` build the Categorical

 2244:     directly, interning the connection dictionary once (no per-row remap).

 2245:     ``to_arrow`` / ``iter_arrow`` / ``__arrow_c_stream__`` emit a generic Arrow

 2246:     form whose per-batch SYMBOL dictionary is compacted to the values each

 2247:     batch uses, which a generic consumer reconciles. So when the target is a

 2248:     polars / pandas frame, the dedicated methods avoid the re-reconciliation

 2249:     that ``polars.from_arrow(result)`` / ``to_arrow().to_pandas()`` pay on

 2250:     SYMBOL-heavy results.

 2251: 

 2252:     Example::

 2253: 

 2254:         with db.query('SELECT * FROM trades WHERE ts > $1',

 2255:                       [datetime.datetime(2026, 7, 1)]) as result:

 2256:             df = polars.from_arrow(result)              # no pyarrow

 2257:             # df = result.to_pandas()                   # no pyarrow

 2258:             # table = pa.table(result)                  # pyarrow required

 2259:     """

 2260: 

+2261:     def __init__(self, _CursorHandle cursor_handle):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_1__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_1__init__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_cursor_handle = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_cursor_handle,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2261, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2261, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2261, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(2, 2261, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, i); __PYX_ERR(2, 2261, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 2)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2261, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2261, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_cursor_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)values[1]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 2261, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cursor_handle), __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle, 1, "cursor_handle", 0))) __PYX_ERR(2, 2261, __pyx_L1_error)
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult___init__(__pyx_self, __pyx_v_self, __pyx_v_cursor_handle);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_cursor_handle) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("questdb._client.QueryResult.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_1__init__, 0, __pyx_mstate_global->__pyx_n_u_QueryResult___init, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2261, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_15) < (0)) __PYX_ERR(2, 2261, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+2262:         self._cursor_handle = cursor_handle

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cursor_handle_2, ((PyObject *)__pyx_v_cursor_handle)) < (0)) __PYX_ERR(2, 2262, __pyx_L1_error)

+2263:         self._cancel_handle = cursor_handle

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cancel_handle, ((PyObject *)__pyx_v_cursor_handle)) < (0)) __PYX_ERR(2, 2263, __pyx_L1_error)

+2264:         self._consumed = False

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_consumed, Py_False) < (0)) __PYX_ERR(2, 2264, __pyx_L1_error)

 2265: 

+2266:     def _take_cursor_handle(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_3_take_cursor_handle(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_3_take_cursor_handle = {"_take_cursor_handle", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_3_take_cursor_handle, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_3_take_cursor_handle(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_take_cursor_handle (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2266, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2266, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_take_cursor_handle", 0) < (0)) __PYX_ERR(2, 2266, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_take_cursor_handle", 1, 1, 1, i); __PYX_ERR(2, 2266, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2266, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_take_cursor_handle", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2266, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult._take_cursor_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_2_take_cursor_handle(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_2_take_cursor_handle(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_handle = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("questdb._client.QueryResult._take_cursor_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_handle);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_3_take_cursor_handle, 0, __pyx_mstate_global->__pyx_n_u_QueryResult__take_cursor_handle, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2266, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_t_15) < (0)) __PYX_ERR(2, 2266, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+2267:         if self._consumed:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_consumed); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2267, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 2267, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+2268:             raise QuestDBError(

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2268, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

+2269:                 QuestDBErrorCode.InvalidApiCall,

    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 2269, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2269, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_6, __pyx_mstate_global->__pyx_kp_u_QueryResult_already_consumed};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2268, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 2268, __pyx_L1_error)

 2270:                 'QueryResult already consumed')

+2271:         if self._cursor_handle is None:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cursor_handle_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2271, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__pyx_t_1 == Py_None);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_t_2)) {
/* … */
  }

+2272:             raise QuestDBError(

    __pyx_t_4 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2272, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);

+2273:                 QuestDBErrorCode.InvalidApiCall,

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2273, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_InvalidApiCall); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 2273, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_7 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
      __pyx_t_7 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_mstate_global->__pyx_kp_u_QueryResult_cursor_was_closed};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2272, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(2, 2272, __pyx_L1_error)

 2274:                 'QueryResult cursor was closed')

+2275:         self._consumed = True

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_consumed, Py_True) < (0)) __PYX_ERR(2, 2275, __pyx_L1_error)

+2276:         handle = self._cursor_handle

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cursor_handle_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_handle = __pyx_t_1;
  __pyx_t_1 = 0;

+2277:         self._cursor_handle = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cursor_handle_2, Py_None) < (0)) __PYX_ERR(2, 2277, __pyx_L1_error)

+2278:         return handle

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_handle);
  __pyx_r = __pyx_v_handle;
  goto __pyx_L0;

 2279: 

+2280:     def _drain(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_5_drain(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_5_drain = {"_drain", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_5_drain, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_5_drain(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_drain (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2280, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2280, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_drain", 0) < (0)) __PYX_ERR(2, 2280, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_drain", 1, 1, 1, i); __PYX_ERR(2, 2280, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2280, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_drain", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2280, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult._drain", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_4_drain(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_4_drain(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("questdb._client.QueryResult._drain", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_5_drain, 0, __pyx_mstate_global->__pyx_n_u_QueryResult__drain, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2280, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_drain, __pyx_t_15) < (0)) __PYX_ERR(2, 2280, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+2281:         _drain_cursor(self._take_cursor_handle())

  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2281, __pyx_L1_error)
  __pyx_t_4 = __pyx_f_7questdb_7_client__drain_cursor(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1)); if (unlikely(__pyx_t_4 == ((__pyx_t_7questdb_7_client_void_int)-1))) __PYX_ERR(2, 2281, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 2282: 

+2283:     def __arrow_c_stream__(self, requested_schema=None):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_7__arrow_c_stream__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_6__arrow_c_stream__, "Arrow C stream PyCapsule protocol (no pyarrow needed). SYMBOL\n        columns arrive compact \342\200\224 each batch's dictionary holds only the values\n        it references \342\200\224 so a consumer that unifies per-batch dictionaries\n        (e.g. ``polars.from_arrow``) reconciles them.\n\n        The returned stream wraps the query cursor, which has thread\n        affinity in the underlying FFI: consume it from one thread at a\n        time, preferably the thread that ran the query. Cross-thread\n        consumption is currently serialised by an internal lock, but the\n        FFI contract does not guarantee that indefinitely.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_7__arrow_c_stream__ = {"__arrow_c_stream__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_7__arrow_c_stream__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_6__arrow_c_stream__};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_7__arrow_c_stream__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_requested_schema = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__arrow_c_stream__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_requested_schema,0};
  PyObject* values[2] = {0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2283, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2283, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2283, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__arrow_c_stream__", 0) < (0)) __PYX_ERR(2, 2283, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__arrow_c_stream__", 0, 1, 2, i); __PYX_ERR(2, 2283, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2283, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2283, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_requested_schema = values[1];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__arrow_c_stream__", 0, 1, 2, __pyx_nargs); __PYX_ERR(2, 2283, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.__arrow_c_stream__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_6__arrow_c_stream__(__pyx_self, __pyx_v_self, __pyx_v_requested_schema);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_6__arrow_c_stream__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_requested_schema) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("questdb._client.QueryResult.__arrow_c_stream__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_7__arrow_c_stream__, 0, __pyx_mstate_global->__pyx_n_u_QueryResult___arrow_c_stream, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_mstate_global->__pyx_tuple[7]);
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_arrow_c_stream, __pyx_t_15) < (0)) __PYX_ERR(2, 2283, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
/* … */
  __pyx_mstate_global->__pyx_tuple[7] = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[7])) __PYX_ERR(2, 2283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[7]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]);

 2284:         """Arrow C stream PyCapsule protocol (no pyarrow needed). SYMBOL

 2285:         columns arrive compact — each batch's dictionary holds only the values

 2286:         it references — so a consumer that unifies per-batch dictionaries

 2287:         (e.g. ``polars.from_arrow``) reconciles them.

 2288: 

 2289:         The returned stream wraps the query cursor, which has thread

 2290:         affinity in the underlying FFI: consume it from one thread at a

 2291:         time, preferably the thread that ran the query. Cross-thread

 2292:         consumption is currently serialised by an internal lock, but the

 2293:         FFI contract does not guarantee that indefinitely.

 2294:         """

+2295:         if requested_schema is not None:

  __pyx_t_1 = (__pyx_v_requested_schema != Py_None);
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+2296:             raise NotImplementedError(

    __pyx_t_3 = NULL;
    __pyx_t_4 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_requested_schema_is_not_supporte};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_NotImplementedError)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2296, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(2, 2296, __pyx_L1_error)

 2297:                 'requested_schema is not supported; consume the stream '

 2298:                 'and project on the consumer side.')

 2299:         # Streaming: hand batches out incrementally. A post-delivery

 2300:         # failover bumps the cursor's _reset_seq; the capsule producer

 2301:         # surfaces FailoverWouldDuplicate rather than feeding the

 2302:         # replayed batch-0 as a duplicate (see _qs_pull).

+2303:         return _make_query_stream_capsule(self._take_cursor_handle())

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2303, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2303, __pyx_L1_error)
  __pyx_t_3 = __pyx_f_7questdb_7_client__make_query_stream_capsule(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2303, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 2304: 

+2305:     def to_arrow(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_9to_arrow(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_8to_arrow, "Read the full result into a ``pyarrow.Table``. Requires pyarrow.\n\n        Materialise-whole: a mid-query failover replays the result\n        transparently \342\200\224 the partial accumulation we hold is discarded\n        from batch-0. The pyarrow-free streaming path\n        (``__arrow_c_stream__`` consumed by ``polars.from_arrow(result)``\n        / ``pa.table(result)``) instead surfaces ``FailoverWouldDuplicate``\n        on a post-delivery failover.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_9to_arrow = {"to_arrow", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_9to_arrow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_8to_arrow};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_9to_arrow(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("to_arrow (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2305, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2305, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "to_arrow", 0) < (0)) __PYX_ERR(2, 2305, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("to_arrow", 1, 1, 1, i); __PYX_ERR(2, 2305, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2305, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("to_arrow", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2305, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.to_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_8to_arrow(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_8to_arrow(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_pa = NULL;
  PyObject *__pyx_v_handle = NULL;
  PyObject *__pyx_v_schema = NULL;
  PyObject *__pyx_v_batches = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("questdb._client.QueryResult.to_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pa);
  __Pyx_XDECREF(__pyx_v_handle);
  __Pyx_XDECREF(__pyx_v_schema);
  __Pyx_XDECREF(__pyx_v_batches);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_9to_arrow, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_to_arrow, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2305, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_to_arrow, __pyx_t_15) < (0)) __PYX_ERR(2, 2305, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

 2306:         """Read the full result into a ``pyarrow.Table``. Requires pyarrow.

 2307: 

 2308:         Materialise-whole: a mid-query failover replays the result

 2309:         transparently — the partial accumulation we hold is discarded

 2310:         from batch-0. The pyarrow-free streaming path

 2311:         (``__arrow_c_stream__`` consumed by ``polars.from_arrow(result)``

 2312:         / ``pa.table(result)``) instead surfaces ``FailoverWouldDuplicate``

 2313:         on a post-delivery failover.

 2314:         """

+2315:         import pyarrow as pa

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2315, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_pa = __pyx_t_1;
  __pyx_t_1 = 0;

+2316:         handle = self._take_cursor_handle()

  __pyx_t_3 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2316, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_handle = __pyx_t_1;
  __pyx_t_1 = 0;

+2317:         schema, batches = _fetch_all_record_batches(handle, pa, True)

  if (!(likely(((__pyx_v_handle) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_handle, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2317, __pyx_L1_error)
  __pyx_t_5.__pyx_n = 1;
  __pyx_t_5.compact = 1;
  __pyx_t_1 = __pyx_f_7questdb_7_client__fetch_all_record_batches(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_v_handle), __pyx_v_pa, &__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2317, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (likely(__pyx_t_1 != Py_None)) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(2, 2317, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
    __Pyx_INCREF(__pyx_t_6);
    #else
    __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2317, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2317, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 2317, __pyx_L1_error)
  }
  __pyx_v_schema = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_batches = __pyx_t_6;
  __pyx_t_6 = 0;

+2318:         if schema is None:

  __pyx_t_7 = (__pyx_v_schema == Py_None);
  if (__pyx_t_7) {
/* … */
  }

+2319:             return pa.table({})

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_6 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_6);
    __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2319, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_table, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2319, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

+2320:         return pa.Table.from_batches(batches, schema)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_Table); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = __pyx_t_6;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_batches, __pyx_v_schema};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_batches, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2320, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 2321: 

+2322:     def to_pandas(self, *, dtype_backend=None, types_mapper=None):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_11to_pandas(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_10to_pandas, "Read the full result into a ``pandas.DataFrame``.\n\n        The default is a native (no pyarrow) hybrid built straight from\n        the QWP column buffers: a nullable integer column\n        with nulls becomes a pandas nullable ``Int*`` (``pd.NA``); without\n        nulls it stays plain numpy. ``double``/``float`` stay numpy with\n        ``NaN``; ``SYMBOL`` \342\206\222 ``Categorical``; ``TIMESTAMP`` \342\206\222\n        ``datetime64`` (``NaT``); strings/decimal/uuid/binary \342\206\222 ``object``.\n        Analysis-safe (aggregations skip ``pd.NA``/``NaN``), and feeds back\n        into :meth:`QuestDB.dataframe` for a type round-trip \342\200\224 the column\n        kinds are carried in ``df.attrs['questdb']``.\n\n        ``dtype_backend=\"pyarrow\"`` / ``\"numpy_nullable\"`` / ``types_mapper``\n        select the pyarrow-backed path instead (``pd.ArrowDtype``, pandas\n        nullable extension dtypes, or a custom mapper) \342\200\224 matching the\n        ``pd.read_sql`` / ``pd.read_parquet`` convention.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_11to_pandas = {"to_pandas", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_11to_pandas, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_10to_pandas};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_11to_pandas(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_dtype_backend = 0;
  PyObject *__pyx_v_types_mapper = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("to_pandas (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_dtype_backend_2,&__pyx_mstate_global->__pyx_n_u_types_mapper,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2322, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2322, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "to_pandas", 0) < (0)) __PYX_ERR(2, 2322, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("to_pandas", 1, 1, 1, i); __PYX_ERR(2, 2322, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2322, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_dtype_backend = values[1];
    __pyx_v_types_mapper = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("to_pandas", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2322, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.to_pandas", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_10to_pandas(__pyx_self, __pyx_v_self, __pyx_v_dtype_backend, __pyx_v_types_mapper);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_10to_pandas(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_dtype_backend, PyObject *__pyx_v_types_mapper) {
  PyObject *__pyx_v_pa = NULL;
  PyObject *__pyx_v_handle = NULL;
  PyObject *__pyx_v_schema = NULL;
  PyObject *__pyx_v_batches = NULL;
  PyObject *__pyx_v_table = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("questdb._client.QueryResult.to_pandas", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pa);
  __Pyx_XDECREF(__pyx_v_handle);
  __Pyx_XDECREF(__pyx_v_schema);
  __Pyx_XDECREF(__pyx_v_batches);
  __Pyx_XDECREF(__pyx_v_table);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  if (PyDict_SetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_dtype_backend_2, Py_None) < (0)) __PYX_ERR(2, 2322, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_types_mapper, Py_None) < (0)) __PYX_ERR(2, 2322, __pyx_L1_error)
  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_11to_pandas, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_to_pandas, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 2322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16);
  #endif
  __Pyx_CyFunction_SetDefaultsKwDict(__pyx_t_16, __pyx_t_15);
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_to_pandas, __pyx_t_16) < (0)) __PYX_ERR(2, 2322, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;

 2323:         """Read the full result into a ``pandas.DataFrame``.

 2324: 

 2325:         The default is a native (no pyarrow) hybrid built straight from

 2326:         the QWP column buffers: a nullable integer column

 2327:         with nulls becomes a pandas nullable ``Int*`` (``pd.NA``); without

 2328:         nulls it stays plain numpy. ``double``/``float`` stay numpy with

 2329:         ``NaN``; ``SYMBOL`` → ``Categorical``; ``TIMESTAMP`` →

 2330:         ``datetime64`` (``NaT``); strings/decimal/uuid/binary → ``object``.

 2331:         Analysis-safe (aggregations skip ``pd.NA``/``NaN``), and feeds back

 2332:         into :meth:`QuestDB.dataframe` for a type round-trip — the column

 2333:         kinds are carried in ``df.attrs['questdb']``.

 2334: 

 2335:         ``dtype_backend="pyarrow"`` / ``"numpy_nullable"`` / ``types_mapper``

 2336:         select the pyarrow-backed path instead (``pd.ArrowDtype``, pandas

 2337:         nullable extension dtypes, or a custom mapper) — matching the

 2338:         ``pd.read_sql`` / ``pd.read_parquet`` convention.

 2339:         """

+2340:         if dtype_backend is not None and types_mapper is not None:

  __pyx_t_2 = (__pyx_v_dtype_backend != Py_None);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_types_mapper != Py_None);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+2341:             raise ValueError(

    __pyx_t_4 = NULL;
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_pass_at_most_one_of_dtype_backen};
      __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2341, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(2, 2341, __pyx_L1_error)

 2342:                 'pass at most one of dtype_backend, types_mapper')

+2343:         if dtype_backend is None and types_mapper is None:

  __pyx_t_2 = (__pyx_v_dtype_backend == Py_None);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L7_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_types_mapper == Py_None);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L7_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+2344:             return self._to_pandas_numpy()

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_pandas_numpy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2344, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __pyx_r = __pyx_t_3;
    __pyx_t_3 = 0;
    goto __pyx_L0;

+2345:         import pyarrow as pa

  __pyx_t_6 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2345, __pyx_L1_error)
  __pyx_t_3 = __pyx_t_6;
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_pa = __pyx_t_3;
  __pyx_t_3 = 0;

+2346:         handle = self._take_cursor_handle()

  __pyx_t_4 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2346, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_v_handle = __pyx_t_3;
  __pyx_t_3 = 0;

+2347:         schema, batches = _fetch_all_record_batches(handle, pa)

  if (!(likely(((__pyx_v_handle) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_handle, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2347, __pyx_L1_error)
  __pyx_t_3 = __pyx_f_7questdb_7_client__fetch_all_record_batches(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_v_handle), __pyx_v_pa, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2347, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (likely(__pyx_t_3 != Py_None)) {
    PyObject* sequence = __pyx_t_3;
    Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(2, 2347, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
    __Pyx_INCREF(__pyx_t_7);
    #else
    __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    #endif
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  } else {
    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 2347, __pyx_L1_error)
  }
  __pyx_v_schema = __pyx_t_4;
  __pyx_t_4 = 0;
  __pyx_v_batches = __pyx_t_7;
  __pyx_t_7 = 0;

+2348:         table = (pa.table({}) if schema is None

  __pyx_t_1 = (__pyx_v_schema == Py_None);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_8 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_8};
      __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_table, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2348, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __pyx_t_3 = __pyx_t_7;
    __pyx_t_7 = 0;
  } else {

+2349:                  else _table_shared_symbol_dict(

    __pyx_t_4 = __pyx_f_7questdb_7_client__table_shared_symbol_dict(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2349, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_3 = __pyx_t_4;
    __pyx_t_4 = 0;
  }
  __pyx_v_table = __pyx_t_3;
  __pyx_t_3 = 0;

+2350:                      pa.Table.from_batches(batches, schema)))

    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_Table); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2350, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_8 = __pyx_t_4;
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_batches, __pyx_v_schema};
      __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_batches, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2350, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }

+2351:         return table.to_pandas(

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_table, __pyx_mstate_global->__pyx_n_u_to_pandas); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2351, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
/* … */
  __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2351, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

+2352:             **_resolve_arrow_to_pandas_kwargs(dtype_backend, types_mapper))

  __pyx_t_7 = __pyx_f_7questdb_7_client__resolve_arrow_to_pandas_kwargs(__pyx_v_dtype_backend, __pyx_v_types_mapper); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  if (unlikely(__pyx_t_7 == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(2, 2352, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_t_7))) {
    #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API
    if (__Pyx_IS_UNIQUELY_REFERENCED(__pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference)) {
      __pyx_t_4 = __pyx_t_7;
      __pyx_t_7 = 0;
    } else
    #endif
    {
      __pyx_t_4 = PyDict_Copy(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2352, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } else {
    __pyx_t_4 = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2351, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  }

 2353: 

+2354:     def to_polars(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_13to_polars(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_12to_polars, "Read the full result into a ``polars.DataFrame``. Requires polars\n        and pyarrow.\n\n        Non-``SYMBOL`` columns keep their exact ``polars.from_arrow`` dtypes\n        (tz-aware ``Datetime``, ``Decimal``, ``Binary``, ``List``/``Array``,\n        \342\200\246). ``SYMBOL`` columns are built into a polars ``Categorical`` directly\n        from their codes + dictionary through a persistent ``Categories``\n        registry \342\200\224 the wire code is its own physical categorical code, so\n        there is no per-row ``Dictionary -> Categorical`` remap. Falls back to\n        ``polars.from_arrow`` when polars' (unstable) ``Categories`` API is\n        unavailable.\n\n        Materialise-whole: a mid-query failover replays the result\n        transparently. This accumulates batches in-library (via pyarrow)\n        so the partial result can be discarded on failover; for the\n        pyarrow-free streaming path consume ``__arrow_c_stream__``\n        directly (``polars.from_arrow(result)``), which surfaces\n        ``FailoverWouldDuplicate`` on a post-delivery failover.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_13to_polars = {"to_polars", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_13to_polars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_12to_polars};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_13to_polars(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("to_polars (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2354, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2354, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "to_polars", 0) < (0)) __PYX_ERR(2, 2354, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("to_polars", 1, 1, 1, i); __PYX_ERR(2, 2354, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2354, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("to_polars", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2354, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.to_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_12to_polars(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_12to_polars(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_pl = NULL;
  PyObject *__pyx_v_ie = NULL;
  PyObject *__pyx_v_pa = NULL;
  PyObject *__pyx_v_handle = NULL;
  PyObject *__pyx_v_schema = NULL;
  PyObject *__pyx_v_batches = NULL;
  PyObject *__pyx_v_table = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client.QueryResult.to_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pl);
  __Pyx_XDECREF(__pyx_v_ie);
  __Pyx_XDECREF(__pyx_v_pa);
  __Pyx_XDECREF(__pyx_v_handle);
  __Pyx_XDECREF(__pyx_v_schema);
  __Pyx_XDECREF(__pyx_v_batches);
  __Pyx_XDECREF(__pyx_v_table);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_13to_polars, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_to_polars, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 2354, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_to_polars, __pyx_t_16) < (0)) __PYX_ERR(2, 2354, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;

 2355:         """Read the full result into a ``polars.DataFrame``. Requires polars

 2356:         and pyarrow.

 2357: 

 2358:         Non-``SYMBOL`` columns keep their exact ``polars.from_arrow`` dtypes

 2359:         (tz-aware ``Datetime``, ``Decimal``, ``Binary``, ``List``/``Array``,

 2360:         …). ``SYMBOL`` columns are built into a polars ``Categorical`` directly

 2361:         from their codes + dictionary through a persistent ``Categories``

 2362:         registry — the wire code is its own physical categorical code, so

 2363:         there is no per-row ``Dictionary -> Categorical`` remap. Falls back to

 2364:         ``polars.from_arrow`` when polars' (unstable) ``Categories`` API is

 2365:         unavailable.

 2366: 

 2367:         Materialise-whole: a mid-query failover replays the result

 2368:         transparently. This accumulates batches in-library (via pyarrow)

 2369:         so the partial result can be discarded on failover; for the

 2370:         pyarrow-free streaming path consume ``__arrow_c_stream__``

 2371:         directly (``polars.from_arrow(result)``), which surfaces

 2372:         ``FailoverWouldDuplicate`` on a post-delivery failover.

 2373:         """

+2374:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L8_try_end:;
  }

+2375:             import polars as pl

      __pyx_t_5 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_polars, 0, 0, NULL, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 2375, __pyx_L3_error)
      __pyx_t_4 = __pyx_t_5;
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_v_pl = __pyx_t_4;
      __pyx_t_4 = 0;

+2376:         except ImportError as ie:

    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ImportError))));
    if (__pyx_t_6) {
      __Pyx_AddTraceback("questdb._client.QueryResult.to_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(2, 2376, __pyx_L5_except_error)
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_v_ie = __pyx_t_7;
      /*try:*/ {
/* … */
      /*finally:*/ {
        __pyx_L14_error:;
        /*exception exit:*/{
          __Pyx_PyThreadState_declare
          __Pyx_PyThreadState_assign
          __pyx_t_5 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
           __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
          if ( unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_14, &__pyx_t_15);
          __Pyx_XGOTREF(__pyx_t_5);
          __Pyx_XGOTREF(__pyx_t_14);
          __Pyx_XGOTREF(__pyx_t_15);
          __Pyx_XGOTREF(__pyx_t_16);
          __Pyx_XGOTREF(__pyx_t_17);
          __Pyx_XGOTREF(__pyx_t_18);
          __pyx_t_6 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
          {
            __Pyx_DECREF(__pyx_v_ie); __pyx_v_ie = 0;
          }
          __Pyx_XGIVEREF(__pyx_t_16);
          __Pyx_XGIVEREF(__pyx_t_17);
          __Pyx_XGIVEREF(__pyx_t_18);
          __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
          __Pyx_XGIVEREF(__pyx_t_5);
          __Pyx_XGIVEREF(__pyx_t_14);
          __Pyx_XGIVEREF(__pyx_t_15);
          __Pyx_ErrRestore(__pyx_t_5, __pyx_t_14, __pyx_t_15);
          __pyx_t_5 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
          __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
          goto __pyx_L5_except_error;
        }
      }
    }
    goto __pyx_L5_except_error;

+2377:             raise ImportError(

        __pyx_t_10 = NULL;
        __pyx_t_11 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_polars_is_required_for_to_polar};
          __pyx_t_9 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2377, __pyx_L14_error)
          __Pyx_GOTREF(__pyx_t_9);
        }

 2378:                 '`polars` is required for `to_polars()`. '

+2379:                 'Install with `pip install polars`.') from ie

        __Pyx_Raise(__pyx_t_9, 0, 0, __pyx_v_ie);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __PYX_ERR(2, 2377, __pyx_L14_error)
      }

+2380:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    goto __pyx_L25_try_end;
    __pyx_L20_error:;
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
    __pyx_L22_except_error:;
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1);
    goto __pyx_L1_error;
    __pyx_L25_try_end:;
  }

+2381:             import pyarrow as pa

      __pyx_t_18 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 2381, __pyx_L20_error)
      __pyx_t_8 = __pyx_t_18;
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_v_pa = __pyx_t_8;
      __pyx_t_8 = 0;

+2382:         except ImportError as ie:

    __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ImportError))));
    if (__pyx_t_12) {
      __Pyx_AddTraceback("questdb._client.QueryResult.to_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_4) < 0) __PYX_ERR(2, 2382, __pyx_L22_except_error)
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_v_ie = __pyx_t_7;
      /*try:*/ {
/* … */
      /*finally:*/ {
        __pyx_L31_error:;
        /*exception exit:*/{
          __Pyx_PyThreadState_declare
          __Pyx_PyThreadState_assign
          __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_5 = 0;
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
           __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_14, &__pyx_t_5);
          if ( unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
          __Pyx_XGOTREF(__pyx_t_18);
          __Pyx_XGOTREF(__pyx_t_17);
          __Pyx_XGOTREF(__pyx_t_16);
          __Pyx_XGOTREF(__pyx_t_15);
          __Pyx_XGOTREF(__pyx_t_14);
          __Pyx_XGOTREF(__pyx_t_5);
          __pyx_t_12 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_19 = __pyx_filename;
          {
            __Pyx_DECREF(__pyx_v_ie); __pyx_v_ie = 0;
          }
          __Pyx_XGIVEREF(__pyx_t_15);
          __Pyx_XGIVEREF(__pyx_t_14);
          __Pyx_XGIVEREF(__pyx_t_5);
          __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_14, __pyx_t_5);
          __Pyx_XGIVEREF(__pyx_t_18);
          __Pyx_XGIVEREF(__pyx_t_17);
          __Pyx_XGIVEREF(__pyx_t_16);
          __Pyx_ErrRestore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
          __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_5 = 0;
          __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_19;
          goto __pyx_L22_except_error;
        }
      }
    }
    goto __pyx_L22_except_error;

+2383:             raise ImportError(

        __pyx_t_10 = NULL;
        __pyx_t_11 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_pyarrow_is_required_for_to_pola};
          __pyx_t_9 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2383, __pyx_L31_error)
          __Pyx_GOTREF(__pyx_t_9);
        }

 2384:                 '`pyarrow` is required for `to_polars()`. '

+2385:                 'Install with `pip install pyarrow`.') from ie

        __Pyx_Raise(__pyx_t_9, 0, 0, __pyx_v_ie);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __PYX_ERR(2, 2383, __pyx_L31_error)
      }

+2386:         handle = self._take_cursor_handle()

  __pyx_t_7 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_7);
  __pyx_t_11 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2386, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_v_handle = __pyx_t_4;
  __pyx_t_4 = 0;

+2387:         schema, batches = _fetch_all_record_batches(handle, pa)

  if (!(likely(((__pyx_v_handle) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_handle, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2387, __pyx_L1_error)
  __pyx_t_4 = __pyx_f_7questdb_7_client__fetch_all_record_batches(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_v_handle), __pyx_v_pa, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2387, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (likely(__pyx_t_4 != Py_None)) {
    PyObject* sequence = __pyx_t_4;
    Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(2, 2387, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1);
    __Pyx_INCREF(__pyx_t_8);
    #else
    __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    #endif
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  } else {
    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 2387, __pyx_L1_error)
  }
  __pyx_v_schema = __pyx_t_7;
  __pyx_t_7 = 0;
  __pyx_v_batches = __pyx_t_8;
  __pyx_t_8 = 0;

+2388:         if schema is None:

  __pyx_t_20 = (__pyx_v_schema == Py_None);
  if (__pyx_t_20) {
/* … */
  }

+2389:             return pl.from_arrow(pa.table({}))

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_8 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_9 = __pyx_v_pa;
    __Pyx_INCREF(__pyx_t_9);
    __pyx_t_10 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 2389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_11 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_10};
      __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_table, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 2389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
    }
    __pyx_t_11 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_7};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

+2390:         table = pa.Table.from_batches(batches, schema)

  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_Table); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2390, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_7 = __pyx_t_8;
  __Pyx_INCREF(__pyx_t_7);
  __pyx_t_11 = 0;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_v_batches, __pyx_v_schema};
    __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_batches, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_v_table = __pyx_t_4;
  __pyx_t_4 = 0;

+2391:         if getattr(pl, 'Categories', None) is None:

  __pyx_t_4 = __Pyx_GetAttr3(__pyx_v_pl, __pyx_mstate_global->__pyx_n_u_Categories, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_20 = (__pyx_t_4 == Py_None);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_20) {
/* … */
  }

+2392:             return pl.from_arrow(table)

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_8 = __pyx_v_pl;
    __Pyx_INCREF(__pyx_t_8);
    __pyx_t_11 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_table};
      __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2392, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    }
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

+2393:         try:

  {
    /*try:*/ {
/* … */
    }
    __pyx_L39_error:;
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
    __pyx_L41_except_error:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L43_try_return:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L0;
    __pyx_L42_except_return:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L0;
  }

+2394:             return _polars_dataframe_hybrid(table, pl, pa, {})

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2394, __pyx_L39_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_8 = __pyx_f_7questdb_7_client__polars_dataframe_hybrid(__pyx_v_table, __pyx_v_pl, __pyx_v_pa, ((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2394, __pyx_L39_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_r = __pyx_t_8;
      __pyx_t_8 = 0;
      goto __pyx_L43_try_return;

+2395:         except Exception:

    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
    if (__pyx_t_6) {
      __Pyx_AddTraceback("questdb._client.QueryResult.to_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(2, 2395, __pyx_L41_except_error)
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_XGOTREF(__pyx_t_7);

+2396:             return pl.from_arrow(table)

      __Pyx_XDECREF(__pyx_r);
      __pyx_t_9 = __pyx_v_pl;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_11 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_table};
        __pyx_t_10 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_arrow, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 2396, __pyx_L41_except_error)
        __Pyx_GOTREF(__pyx_t_10);
      }
      __pyx_r = __pyx_t_10;
      __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      goto __pyx_L42_except_return;
    }
    goto __pyx_L41_except_error;

 2397: 

+2398:     def _to_pandas_numpy(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_15_to_pandas_numpy(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_15_to_pandas_numpy = {"_to_pandas_numpy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_15_to_pandas_numpy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_15_to_pandas_numpy(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_to_pandas_numpy (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2398, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2398, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_to_pandas_numpy", 0) < (0)) __PYX_ERR(2, 2398, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_to_pandas_numpy", 1, 1, 1, i); __PYX_ERR(2, 2398, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2398, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_to_pandas_numpy", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2398, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult._to_pandas_numpy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_14_to_pandas_numpy(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_14_to_pandas_numpy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("questdb._client.QueryResult._to_pandas_numpy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_7questdb_7_client_11QueryResult_18generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_15_to_pandas_numpy, 0, __pyx_mstate_global->__pyx_n_u_QueryResult__to_pandas_numpy, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 2398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_to_pandas_numpy, __pyx_t_16) < (0)) __PYX_ERR(2, 2398, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;

+2399:         return _numpy_frame_from_cursor(self._take_cursor_handle())

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2399, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2399, __pyx_L1_error)
  __pyx_t_2 = __pyx_f_7questdb_7_client__numpy_frame_from_cursor(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2399, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

 2400: 

+2401:     def iter_arrow(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_17iter_arrow(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_16iter_arrow, "Iterate result batches as ``pyarrow.RecordBatch``.\n\n        Streaming: a mid-query failover after the first batch has been\n        yielded surfaces ``QuestDBErrorCode.FailoverWouldDuplicate`` (the\n        already-yielded batches cannot be discarded); re-issue the query.\n        If the iterator is abandoned partway, cleanup runs at the next\n        garbage-collection cycle; call :meth:`close` (or use the context-\n        manager) for deterministic release.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_17iter_arrow = {"iter_arrow", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_17iter_arrow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_16iter_arrow};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_17iter_arrow(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("iter_arrow (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2401, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2401, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "iter_arrow", 0) < (0)) __PYX_ERR(2, 2401, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("iter_arrow", 1, 1, 1, i); __PYX_ERR(2, 2401, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2401, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("iter_arrow", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2401, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.iter_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_16iter_arrow(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_16iter_arrow(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_6_iter_arrow *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_6_iter_arrow *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct_6_iter_arrow(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct_6_iter_arrow, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct_6_iter_arrow *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 2401, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_self = __pyx_v_self;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7questdb_7_client_11QueryResult_18generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_iter_arrow, __pyx_mstate_global->__pyx_n_u_QueryResult_iter_arrow, __pyx_mstate_global->__pyx_n_u_questdb__client); if (unlikely(!gen)) __PYX_ERR(2, 2401, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("questdb._client.QueryResult.iter_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_7questdb_7_client_11QueryResult_18generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("iter_arrow", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(2, 2401, __pyx_L1_error)
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("iter_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_17iter_arrow, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_iter_arrow, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 2401, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_16);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_iter_arrow, __pyx_t_16) < (0)) __PYX_ERR(2, 2401, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct_6_iter_arrow {
  PyObject_HEAD
  PyObject *__pyx_v_batch;
  PyObject *__pyx_v_reader;
  PyObject *__pyx_v_self;
  PyObject *__pyx_t_0;
  Py_ssize_t __pyx_t_1;
  PyObject *(*__pyx_t_2)(PyObject *);
};

 2402:         """Iterate result batches as ``pyarrow.RecordBatch``.

 2403: 

 2404:         Streaming: a mid-query failover after the first batch has been

 2405:         yielded surfaces ``QuestDBErrorCode.FailoverWouldDuplicate`` (the

 2406:         already-yielded batches cannot be discarded); re-issue the query.

 2407:         If the iterator is abandoned partway, cleanup runs at the next

 2408:         garbage-collection cycle; call :meth:`close` (or use the context-

 2409:         manager) for deterministic release.

 2410:         """

+2411:         reader = _build_record_batch_reader(self._take_cursor_handle(), True)

  __pyx_t_2 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2411, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2411, __pyx_L1_error)
  __pyx_t_4.__pyx_n = 1;
  __pyx_t_4.compact = 1;
  __pyx_t_2 = __pyx_f_7questdb_7_client__build_record_batch_reader(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1), &__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2411, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_cur_scope->__pyx_v_reader = __pyx_t_2;
  __pyx_t_2 = 0;

+2412:         for batch in reader:

  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_reader)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_reader)) {
    __pyx_t_2 = __pyx_cur_scope->__pyx_v_reader; __Pyx_INCREF(__pyx_t_2);
    __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_reader); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2412, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_6)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2412, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2412, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2412, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_6(__pyx_t_2);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 2412, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_batch);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_batch, __pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_1);
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

+2413:             yield batch

    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_batch);
    __pyx_r = __pyx_cur_scope->__pyx_v_batch;
    __Pyx_XGIVEREF(__pyx_t_2);
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_2;
    __pyx_cur_scope->__pyx_t_1 = __pyx_t_5;
    __pyx_cur_scope->__pyx_t_2 = __pyx_t_6;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L6_resume_from_yield:;
    __pyx_t_2 = __pyx_cur_scope->__pyx_t_0;
    __pyx_cur_scope->__pyx_t_0 = 0;
    __Pyx_XGOTREF(__pyx_t_2);
    __pyx_t_5 = __pyx_cur_scope->__pyx_t_1;
    __pyx_t_6 = __pyx_cur_scope->__pyx_t_2;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 2413, __pyx_L1_error)

 2414: 

+2415:     def iter_pandas(self, *, dtype_backend=None, types_mapper=None):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_20iter_pandas(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_19iter_pandas, "Iterate result batches as ``pandas.DataFrame``.\n\n        Mirrors :meth:`to_pandas`: with no arguments each batch is\n        materialised straight into numpy (no pyarrow, sentinel-preserving,\n        ``df.attrs['questdb']`` per batch). ``dtype_backend`` /\n        ``types_mapper`` select the pyarrow-backed path instead.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_20iter_pandas = {"iter_pandas", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_20iter_pandas, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_19iter_pandas};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_20iter_pandas(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_dtype_backend = 0;
  PyObject *__pyx_v_types_mapper = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("iter_pandas (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_dtype_backend_2,&__pyx_mstate_global->__pyx_n_u_types_mapper,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2415, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2415, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "iter_pandas", 0) < (0)) __PYX_ERR(2, 2415, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_None));
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("iter_pandas", 1, 1, 1, i); __PYX_ERR(2, 2415, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2415, __pyx_L3_error)
      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
      if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_None));
    }
    __pyx_v_self = values[0];
    __pyx_v_dtype_backend = values[1];
    __pyx_v_types_mapper = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("iter_pandas", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2415, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.iter_pandas", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_19iter_pandas(__pyx_self, __pyx_v_self, __pyx_v_dtype_backend, __pyx_v_types_mapper);

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_19iter_pandas(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_dtype_backend, PyObject *__pyx_v_types_mapper) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("questdb._client.QueryResult.iter_pandas", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_7questdb_7_client_11QueryResult_23generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
  __pyx_t_16 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 2415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_16);
  if (PyDict_SetItem(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_dtype_backend_2, Py_None) < (0)) __PYX_ERR(2, 2415, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_types_mapper, Py_None) < (0)) __PYX_ERR(2, 2415, __pyx_L1_error)
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_20iter_pandas, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_iter_pandas, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  __Pyx_CyFunction_SetDefaultsKwDict(__pyx_t_15, __pyx_t_16);
  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_iter_pandas, __pyx_t_15) < (0)) __PYX_ERR(2, 2415, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

 2416:         """Iterate result batches as ``pandas.DataFrame``.

 2417: 

 2418:         Mirrors :meth:`to_pandas`: with no arguments each batch is

 2419:         materialised straight into numpy (no pyarrow, sentinel-preserving,

 2420:         ``df.attrs['questdb']`` per batch). ``dtype_backend`` /

 2421:         ``types_mapper`` select the pyarrow-backed path instead.

 2422:         """

+2423:         if dtype_backend is not None and types_mapper is not None:

  __pyx_t_2 = (__pyx_v_dtype_backend != Py_None);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_types_mapper != Py_None);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+2424:             raise ValueError(

    __pyx_t_4 = NULL;
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_pass_at_most_one_of_dtype_backen};
      __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2424, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(2, 2424, __pyx_L1_error)

 2425:                 'pass at most one of dtype_backend, types_mapper')

+2426:         if dtype_backend is None and types_mapper is None:

  __pyx_t_2 = (__pyx_v_dtype_backend == Py_None);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L7_bool_binop_done;
  }
  __pyx_t_2 = (__pyx_v_types_mapper == Py_None);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L7_bool_binop_done:;
  if (__pyx_t_1) {
/* … */
  }

+2427:             return _NumpyBatchIter(self._take_cursor_handle())

    __Pyx_XDECREF(__pyx_r);
    __pyx_t_4 = NULL;
    __pyx_t_7 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
      __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2427, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    __pyx_t_5 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6};
      __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_7questdb_7_client__NumpyBatchIter, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2427, __pyx_L1_error)
      __Pyx_GOTREF((PyObject *)__pyx_t_3);
    }
    __pyx_r = ((PyObject *)__pyx_t_3);
    __pyx_t_3 = 0;
    goto __pyx_L0;

+2428:         return self._iter_pandas_arrow(dtype_backend, types_mapper)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_6 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_6);
  __pyx_t_5 = 0;
  {
    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_dtype_backend, __pyx_v_types_mapper};
    __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_iter_pandas_arrow, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2428, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  }
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

 2429: 

+2430:     def _iter_pandas_arrow(self, dtype_backend, types_mapper):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_22_iter_pandas_arrow(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_22_iter_pandas_arrow = {"_iter_pandas_arrow", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_22_iter_pandas_arrow, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_22_iter_pandas_arrow(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  PyObject *__pyx_v_dtype_backend = 0;
  PyObject *__pyx_v_types_mapper = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_iter_pandas_arrow (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_dtype_backend_2,&__pyx_mstate_global->__pyx_n_u_types_mapper,0};
  PyObject* values[3] = {0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2430, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 2430, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2430, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2430, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_iter_pandas_arrow", 0) < (0)) __PYX_ERR(2, 2430, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_iter_pandas_arrow", 1, 3, 3, i); __PYX_ERR(2, 2430, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 3)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2430, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2430, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 2430, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_dtype_backend = values[1];
    __pyx_v_types_mapper = values[2];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_iter_pandas_arrow", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 2430, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult._iter_pandas_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_21_iter_pandas_arrow(__pyx_self, __pyx_v_self, __pyx_v_dtype_backend, __pyx_v_types_mapper);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_21_iter_pandas_arrow(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_dtype_backend, PyObject *__pyx_v_types_mapper) {
  struct __pyx_obj_7questdb_7_client___pyx_scope_struct_7__iter_pandas_arrow *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_7questdb_7_client___pyx_scope_struct_7__iter_pandas_arrow *)__pyx_tp_new_7questdb_7_client___pyx_scope_struct_7__iter_pandas_arrow(__pyx_mstate_global->__pyx_ptype_7questdb_7_client___pyx_scope_struct_7__iter_pandas_arrow, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_7questdb_7_client___pyx_scope_struct_7__iter_pandas_arrow *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(2, 2430, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_self = __pyx_v_self;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self);
  __pyx_cur_scope->__pyx_v_dtype_backend = __pyx_v_dtype_backend;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_dtype_backend);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_dtype_backend);
  __pyx_cur_scope->__pyx_v_types_mapper = __pyx_v_types_mapper;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_types_mapper);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_types_mapper);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7questdb_7_client_11QueryResult_23generator1, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_iter_pandas_arrow, __pyx_mstate_global->__pyx_n_u_QueryResult__iter_pandas_arrow, __pyx_mstate_global->__pyx_n_u_questdb__client); if (unlikely(!gen)) __PYX_ERR(2, 2430, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("questdb._client.QueryResult._iter_pandas_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_7questdb_7_client_11QueryResult_23generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_iter_pandas_arrow", 0);
  __pyx_L3_first_run:;
  if (unlikely(__pyx_sent_value != Py_None)) {
    if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator");
    __PYX_ERR(2, 2430, __pyx_L1_error)
  }
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("_iter_pandas_arrow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_22_iter_pandas_arrow, 0, __pyx_mstate_global->__pyx_n_u_QueryResult__iter_pandas_arrow, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2430, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_iter_pandas_arrow, __pyx_t_15) < (0)) __PYX_ERR(2, 2430, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
/* … */
struct __pyx_obj_7questdb_7_client___pyx_scope_struct_7__iter_pandas_arrow {
  PyObject_HEAD
  PyObject *__pyx_v_batch;
  PyObject *__pyx_v_dtype_backend;
  PyObject *__pyx_v_kwargs;
  PyObject *__pyx_v_pa;
  PyObject *__pyx_v_reader;
  PyObject *__pyx_v_self;
  PyObject *__pyx_v_table;
  PyObject *__pyx_v_types_mapper;
  PyObject *__pyx_t_0;
  Py_ssize_t __pyx_t_1;
  PyObject *(*__pyx_t_2)(PyObject *);
};

+2431:         import pyarrow as pa

  __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2431, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_2;
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_pa = __pyx_t_1;
  __pyx_t_1 = 0;

+2432:         kwargs = _resolve_arrow_to_pandas_kwargs(dtype_backend, types_mapper)

  __pyx_t_1 = __pyx_f_7questdb_7_client__resolve_arrow_to_pandas_kwargs(__pyx_cur_scope->__pyx_v_dtype_backend, __pyx_cur_scope->__pyx_v_types_mapper); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2432, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_cur_scope->__pyx_v_kwargs = __pyx_t_1;
  __pyx_t_1 = 0;

+2433:         reader = _build_record_batch_reader(self._take_cursor_handle())

  __pyx_t_3 = __pyx_cur_scope->__pyx_v_self;
  __Pyx_INCREF(__pyx_t_3);
  __pyx_t_4 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2433, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2433, __pyx_L1_error)
  __pyx_t_3 = __pyx_f_7questdb_7_client__build_record_batch_reader(((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1), NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2433, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_GIVEREF(__pyx_t_3);
  __pyx_cur_scope->__pyx_v_reader = __pyx_t_3;
  __pyx_t_3 = 0;

+2434:         for batch in reader:

  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_reader)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_reader)) {
    __pyx_t_3 = __pyx_cur_scope->__pyx_v_reader; __Pyx_INCREF(__pyx_t_3);
    __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
  } else {
    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_reader); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2434, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 2434, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_6)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2434, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_5;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 2434, __pyx_L1_error)
          #endif
          if (__pyx_t_5 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
        #else
        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
        #endif
        ++__pyx_t_5;
      }
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2434, __pyx_L1_error)
    } else {
      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
      if (unlikely(!__pyx_t_1)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 2434, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_batch);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_batch, __pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_1);
    __pyx_t_1 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

+2435:             table = _table_shared_symbol_dict(pa.Table.from_batches([batch]))

    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pa, __pyx_mstate_global->__pyx_n_u_Table); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2435, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = __pyx_t_8;
    __Pyx_INCREF(__pyx_t_7);
    __pyx_t_9 = PyList_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2435, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_INCREF(__pyx_cur_scope->__pyx_v_batch);
    __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_batch);
    if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_cur_scope->__pyx_v_batch) != (0)) __PYX_ERR(2, 2435, __pyx_L1_error);
    __pyx_t_4 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_9};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_from_batches, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2435, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_8 = __pyx_f_7questdb_7_client__table_shared_symbol_dict(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2435, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_table);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_table, __pyx_t_8);
    __Pyx_GIVEREF(__pyx_t_8);
    __pyx_t_8 = 0;

+2436:             yield table.to_pandas(**kwargs)

    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_table, __pyx_mstate_global->__pyx_n_u_to_pandas); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2436, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (unlikely(__pyx_cur_scope->__pyx_v_kwargs == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
      __PYX_ERR(2, 2436, __pyx_L1_error)
    }
    if (likely(PyDict_CheckExact(__pyx_cur_scope->__pyx_v_kwargs))) {
      __pyx_t_1 = PyDict_Copy(__pyx_cur_scope->__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2436, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    } else {
      __pyx_t_1 = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, __pyx_cur_scope->__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2436, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2436, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_r = __pyx_t_9;
    __pyx_t_9 = 0;
    __Pyx_XGIVEREF(__pyx_t_3);
    __pyx_cur_scope->__pyx_t_0 = __pyx_t_3;
    __pyx_cur_scope->__pyx_t_1 = __pyx_t_5;
    __pyx_cur_scope->__pyx_t_2 = __pyx_t_6;
    __Pyx_XGIVEREF(__pyx_r);
    __Pyx_RefNannyFinishContext();
    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
    /* return from generator, yielding value */
    __pyx_generator->resume_label = 1;
    return __pyx_r;
    __pyx_L6_resume_from_yield:;
    __pyx_t_3 = __pyx_cur_scope->__pyx_t_0;
    __pyx_cur_scope->__pyx_t_0 = 0;
    __Pyx_XGOTREF(__pyx_t_3);
    __pyx_t_5 = __pyx_cur_scope->__pyx_t_1;
    __pyx_t_6 = __pyx_cur_scope->__pyx_t_2;
    if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 2436, __pyx_L1_error)

 2437: 

+2438:     def iter_polars(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_25iter_polars(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_24iter_polars, "Iterate result batches as ``polars.DataFrame``.\n\n        Mirrors :meth:`to_polars` per batch (same ``Categorical`` SYMBOL\n        handling) for streaming / low-peak-memory consumption. Every batch's\n        SYMBOL Categoricals share one persistent ``Categories`` identity, so\n        ``polars.concat`` over the yielded frames stitches without a\n        categories-mismatch error.\n\n        Streaming: a mid-query failover after the first batch has been yielded\n        surfaces ``QuestDBErrorCode.FailoverWouldDuplicate``; re-issue the\n        query. Requires polars and pyarrow.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_25iter_polars = {"iter_polars", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_25iter_polars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_24iter_polars};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_25iter_polars(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("iter_polars (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2438, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2438, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "iter_polars", 0) < (0)) __PYX_ERR(2, 2438, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("iter_polars", 1, 1, 1, i); __PYX_ERR(2, 2438, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2438, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("iter_polars", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2438, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.iter_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_24iter_polars(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_24iter_polars(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_v_pl = NULL;
  PyObject *__pyx_v_ie = NULL;
  PyObject *__pyx_v_pa = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("questdb._client.QueryResult.iter_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pl);
  __Pyx_XDECREF(__pyx_v_ie);
  __Pyx_XDECREF(__pyx_v_pa);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_25iter_polars, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_iter_polars, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2438, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_iter_polars, __pyx_t_15) < (0)) __PYX_ERR(2, 2438, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

 2439:         """Iterate result batches as ``polars.DataFrame``.

 2440: 

 2441:         Mirrors :meth:`to_polars` per batch (same ``Categorical`` SYMBOL

 2442:         handling) for streaming / low-peak-memory consumption. Every batch's

 2443:         SYMBOL Categoricals share one persistent ``Categories`` identity, so

 2444:         ``polars.concat`` over the yielded frames stitches without a

 2445:         categories-mismatch error.

 2446: 

 2447:         Streaming: a mid-query failover after the first batch has been yielded

 2448:         surfaces ``QuestDBErrorCode.FailoverWouldDuplicate``; re-issue the

 2449:         query. Requires polars and pyarrow.

 2450:         """

+2451:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L8_try_end:;
  }

+2452:             import polars as pl

      __pyx_t_5 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_polars, 0, 0, NULL, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 2452, __pyx_L3_error)
      __pyx_t_4 = __pyx_t_5;
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_v_pl = __pyx_t_4;
      __pyx_t_4 = 0;

+2453:         except ImportError as ie:

    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ImportError))));
    if (__pyx_t_6) {
      __Pyx_AddTraceback("questdb._client.QueryResult.iter_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(2, 2453, __pyx_L5_except_error)
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_v_ie = __pyx_t_7;
      /*try:*/ {
/* … */
      /*finally:*/ {
        __pyx_L14_error:;
        /*exception exit:*/{
          __Pyx_PyThreadState_declare
          __Pyx_PyThreadState_assign
          __pyx_t_5 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
           __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
          if ( unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_14, &__pyx_t_15);
          __Pyx_XGOTREF(__pyx_t_5);
          __Pyx_XGOTREF(__pyx_t_14);
          __Pyx_XGOTREF(__pyx_t_15);
          __Pyx_XGOTREF(__pyx_t_16);
          __Pyx_XGOTREF(__pyx_t_17);
          __Pyx_XGOTREF(__pyx_t_18);
          __pyx_t_6 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
          {
            __Pyx_DECREF(__pyx_v_ie); __pyx_v_ie = 0;
          }
          __Pyx_XGIVEREF(__pyx_t_16);
          __Pyx_XGIVEREF(__pyx_t_17);
          __Pyx_XGIVEREF(__pyx_t_18);
          __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
          __Pyx_XGIVEREF(__pyx_t_5);
          __Pyx_XGIVEREF(__pyx_t_14);
          __Pyx_XGIVEREF(__pyx_t_15);
          __Pyx_ErrRestore(__pyx_t_5, __pyx_t_14, __pyx_t_15);
          __pyx_t_5 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0;
          __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
          goto __pyx_L5_except_error;
        }
      }
    }
    goto __pyx_L5_except_error;

+2454:             raise ImportError(

        __pyx_t_10 = NULL;
        __pyx_t_11 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_polars_is_required_for_iter_pol};
          __pyx_t_9 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2454, __pyx_L14_error)
          __Pyx_GOTREF(__pyx_t_9);
        }

 2455:                 '`polars` is required for `iter_polars()`. '

+2456:                 'Install with `pip install polars`.') from ie

        __Pyx_Raise(__pyx_t_9, 0, 0, __pyx_v_ie);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __PYX_ERR(2, 2454, __pyx_L14_error)
      }

+2457:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    goto __pyx_L25_try_end;
    __pyx_L20_error:;
    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
    __pyx_L22_except_error:;
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1);
    goto __pyx_L1_error;
    __pyx_L25_try_end:;
  }

+2458:             import pyarrow as pa

      __pyx_t_18 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pyarrow, 0, 0, NULL, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 2458, __pyx_L20_error)
      __pyx_t_8 = __pyx_t_18;
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_v_pa = __pyx_t_8;
      __pyx_t_8 = 0;

+2459:         except ImportError as ie:

    __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ImportError))));
    if (__pyx_t_12) {
      __Pyx_AddTraceback("questdb._client.QueryResult.iter_polars", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_4) < 0) __PYX_ERR(2, 2459, __pyx_L22_except_error)
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_7);
      __pyx_v_ie = __pyx_t_7;
      /*try:*/ {
/* … */
      /*finally:*/ {
        __pyx_L31_error:;
        /*exception exit:*/{
          __Pyx_PyThreadState_declare
          __Pyx_PyThreadState_assign
          __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_5 = 0;
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
           __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_14, &__pyx_t_5);
          if ( unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
          __Pyx_XGOTREF(__pyx_t_18);
          __Pyx_XGOTREF(__pyx_t_17);
          __Pyx_XGOTREF(__pyx_t_16);
          __Pyx_XGOTREF(__pyx_t_15);
          __Pyx_XGOTREF(__pyx_t_14);
          __Pyx_XGOTREF(__pyx_t_5);
          __pyx_t_12 = __pyx_lineno; __pyx_t_6 = __pyx_clineno; __pyx_t_19 = __pyx_filename;
          {
            __Pyx_DECREF(__pyx_v_ie); __pyx_v_ie = 0;
          }
          __Pyx_XGIVEREF(__pyx_t_15);
          __Pyx_XGIVEREF(__pyx_t_14);
          __Pyx_XGIVEREF(__pyx_t_5);
          __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_14, __pyx_t_5);
          __Pyx_XGIVEREF(__pyx_t_18);
          __Pyx_XGIVEREF(__pyx_t_17);
          __Pyx_XGIVEREF(__pyx_t_16);
          __Pyx_ErrRestore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
          __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_5 = 0;
          __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_6; __pyx_filename = __pyx_t_19;
          goto __pyx_L22_except_error;
        }
      }
    }
    goto __pyx_L22_except_error;

+2460:             raise ImportError(

        __pyx_t_10 = NULL;
        __pyx_t_11 = 1;
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_mstate_global->__pyx_kp_u_pyarrow_is_required_for_iter_po};
          __pyx_t_9 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2460, __pyx_L31_error)
          __Pyx_GOTREF(__pyx_t_9);
        }

 2461:                 '`pyarrow` is required for `iter_polars()`. '

+2462:                 'Install with `pip install pyarrow`.') from ie

        __Pyx_Raise(__pyx_t_9, 0, 0, __pyx_v_ie);
        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        __PYX_ERR(2, 2460, __pyx_L31_error)
      }

+2463:         return _PolarsBatchIter(self._take_cursor_handle(), pl, pa)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_7 = NULL;
  __pyx_t_9 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_9);
  __pyx_t_11 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL};
    __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_take_cursor_handle, __pyx_callargs+__pyx_t_11, (1-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2463, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
  }
  __pyx_t_11 = 1;
  {
    PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_t_8, __pyx_v_pl, __pyx_v_pa};
    __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_7questdb_7_client__PolarsBatchIter, __pyx_callargs+__pyx_t_11, (4-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2463, __pyx_L1_error)
    __Pyx_GOTREF((PyObject *)__pyx_t_4);
  }
  __pyx_r = ((PyObject *)__pyx_t_4);
  __pyx_t_4 = 0;
  goto __pyx_L0;

 2464: 

+2465:     def cancel(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_27cancel(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_26cancel, "Cancel the query and drain to terminal.\n\n        The result remains open; call :meth:`close` before starting\n        another query on the same reader. On failure, the result is\n        closed. Idempotent after success.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_27cancel = {"cancel", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_27cancel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_26cancel};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_27cancel(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cancel (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2465, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2465, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "cancel", 0) < (0)) __PYX_ERR(2, 2465, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("cancel", 1, 1, 1, i); __PYX_ERR(2, 2465, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2465, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("cancel", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2465, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_26cancel(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_26cancel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle = 0;
  questdb_error *__pyx_v_err;
  int __pyx_v_ok;
  int __pyx_v_reusable;
  struct qwp_reader_cursor *__pyx_v_cursor;
  PyObject *__pyx_v_exc = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("questdb._client.QueryResult.cancel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
  __Pyx_XDECREF(__pyx_v_exc);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_27cancel, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_cancel, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2465, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_cancel, __pyx_t_15) < (0)) __PYX_ERR(2, 2465, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

 2466:         """Cancel the query and drain to terminal.

 2467: 

 2468:         The result remains open; call :meth:`close` before starting

 2469:         another query on the same reader. On failure, the result is

 2470:         closed. Idempotent after success.

 2471:         """

+2472:         cdef _CursorHandle handle = self._cancel_handle

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cancel_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2472, __pyx_L1_error)
  __pyx_v_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1);
  __pyx_t_1 = 0;

+2473:         cdef questdb_error* err = NULL

  __pyx_v_err = NULL;

 2474:         cdef bint ok

 2475:         cdef bint reusable

 2476:         cdef qwp_reader_cursor* cursor

 2477:         cdef object exc

+2478:         if handle is None:

  __pyx_t_2 = (((PyObject *)__pyx_v_handle) == Py_None);
  if (__pyx_t_2) {
/* … */
  }

+2479:             return

    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

+2480:         with handle._lock:

  /*with:*/ {
    __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2480, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = NULL;
    __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_v_handle->_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 2480, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = 1;
    #if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
      assert(__pyx_t_4);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
      __pyx_t_6 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2480, __pyx_L4_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    /*try:*/ {
      {
        /*try:*/ {
/* … */
        }
        goto __pyx_L13_try_end;
        __pyx_L12_try_return:;
        goto __pyx_L5_return;
        __pyx_L13_try_end:;
      }
    }
    /*finally:*/ {
      /*normal exit:*/{
        if (__pyx_t_3) {
          __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[2], NULL);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2480, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_9);
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
        }
        goto __pyx_L7;
      }
      __pyx_L5_return: {
        __pyx_t_9 = __pyx_r;
        __pyx_r = 0;
        if (__pyx_t_3) {
          __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[2], NULL);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2480, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        }
        __pyx_r = __pyx_t_9;
        __pyx_t_9 = 0;
        goto __pyx_L0;
      }
      __pyx_L7:;
    }
    goto __pyx_L18;
    __pyx_L4_error:;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L1_error;
    __pyx_L18:;
  }

+2481:             cursor = handle._cursor

          __pyx_t_10 = __pyx_v_handle->_cursor;
          __pyx_v_cursor = __pyx_t_10;

+2482:             if cursor == NULL:

          __pyx_t_2 = (__pyx_v_cursor == NULL);
          if (__pyx_t_2) {
/* … */
          }

+2483:                 return

            __Pyx_XDECREF(__pyx_r);
            __pyx_r = Py_None; __Pyx_INCREF(Py_None);
            goto __pyx_L12_try_return;

+2484:             with nogil:

          {
              PyThreadState * _save;
              _save = PyEval_SaveThread();
              __Pyx_FastGIL_Remember();
              /*try:*/ {
/* … */
              /*finally:*/ {
                /*normal exit:*/{
                  __Pyx_FastGIL_Forget();
                  PyEval_RestoreThread(_save);
                  goto __pyx_L17;
                }
                __pyx_L17:;
              }
          }

+2485:                 ok = qwp_reader_cursor_cancel(cursor, &err)

                __pyx_v_ok = qwp_reader_cursor_cancel(__pyx_v_cursor, (&__pyx_v_err));

+2486:                 reusable = qwp_reader_cursor_connection_reusable(cursor)

                __pyx_v_reusable = qwp_reader_cursor_connection_reusable(__pyx_v_cursor);
              }

+2487:         if reusable:

  if (__pyx_v_reusable) {
/* … */
  }

+2488:             _mark_reader_drained(handle)

    __pyx_f_7questdb_7_client__mark_reader_drained(__pyx_v_handle);

+2489:         if not ok:

  __pyx_t_2 = (!__pyx_v_ok);
  if (__pyx_t_2) {
/* … */
  }

+2490:             if err != NULL:

    __pyx_t_2 = (__pyx_v_err != NULL);
    if (__pyx_t_2) {
/* … */
      goto __pyx_L21;
    }

+2491:                 exc = _reader_err_to_py(err)

      __pyx_t_1 = __pyx_f_7questdb_7_client__reader_err_to_py(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2491, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_v_exc = __pyx_t_1;
      __pyx_t_1 = 0;

 2492:             else:

+2493:                 exc = QuestDBError(

    /*else*/ {
      __pyx_t_5 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_QuestDBError); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2493, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);

+2494:                     QuestDBErrorCode.ServerFlushError,

      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_QuestDBErrorCode); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 2494, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_ServerFlushError); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 2494, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      __pyx_t_6 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
        assert(__pyx_t_5);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
        __pyx_t_6 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_12, __pyx_mstate_global->__pyx_kp_u_qwp_reader_cursor_cancel_returne};
        __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2493, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
      }
      __pyx_v_exc = __pyx_t_1;
      __pyx_t_1 = 0;
    }
    __pyx_L21:;

 2495:                     'qwp_reader_cursor_cancel returned false '

 2496:                     'without setting err_out')

+2497:             self.close()

    __pyx_t_4 = __pyx_v_self;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_6 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
      __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_close, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2497, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2498:             raise exc

    __Pyx_Raise(__pyx_v_exc, 0, 0, 0);
    __PYX_ERR(2, 2498, __pyx_L1_error)

 2499: 

+2500:     def close(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_29close(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_7questdb_7_client_11QueryResult_28close, "Release the cursor and reader. Idempotent.\n\n        Terminal connections return to the pool; others are dropped.\n        This does not cancel the query. Outstanding iterators become\n        invalid.\n        ");
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_29close = {"close", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_29close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7questdb_7_client_11QueryResult_28close};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_29close(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("close (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2500, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2500, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "close", 0) < (0)) __PYX_ERR(2, 2500, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("close", 1, 1, 1, i); __PYX_ERR(2, 2500, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2500, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("close", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2500, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_28close(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_28close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("questdb._client.QueryResult.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_29close, 0, __pyx_mstate_global->__pyx_n_u_QueryResult_close, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2500, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_close, __pyx_t_15) < (0)) __PYX_ERR(2, 2500, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

 2501:         """Release the cursor and reader. Idempotent.

 2502: 

 2503:         Terminal connections return to the pool; others are dropped.

 2504:         This does not cancel the query. Outstanding iterators become

 2505:         invalid.

 2506:         """

+2507:         cdef _CursorHandle handle = self._cancel_handle

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cancel_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2507, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2507, __pyx_L1_error)
  __pyx_v_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_1);
  __pyx_t_1 = 0;

+2508:         self._cursor_handle = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cursor_handle_2, Py_None) < (0)) __PYX_ERR(2, 2508, __pyx_L1_error)

+2509:         self._cancel_handle = None

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cancel_handle, Py_None) < (0)) __PYX_ERR(2, 2509, __pyx_L1_error)

+2510:         self._consumed = True

  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_consumed, Py_True) < (0)) __PYX_ERR(2, 2510, __pyx_L1_error)

+2511:         if handle is not None:

  __pyx_t_2 = (((PyObject *)__pyx_v_handle) != Py_None);
  if (__pyx_t_2) {
/* … */
  }

+2512:             handle._free()

    ((struct __pyx_vtabstruct_7questdb_7_client__CursorHandle *)__pyx_v_handle->__pyx_vtab)->_free(__pyx_v_handle);

 2513: 

+2514:     def __enter__(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_31__enter__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_31__enter__ = {"__enter__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_31__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_31__enter__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2514, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2514, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__enter__", 0) < (0)) __PYX_ERR(2, 2514, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__enter__", 1, 1, 1, i); __PYX_ERR(2, 2514, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2514, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__enter__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2514, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_30__enter__(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_30__enter__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_31__enter__, 0, __pyx_mstate_global->__pyx_n_u_QueryResult___enter, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2514, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_enter, __pyx_t_15) < (0)) __PYX_ERR(2, 2514, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+2515:         return self

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_self);
  __pyx_r = __pyx_v_self;
  goto __pyx_L0;

 2516: 

+2517:     def __exit__(self, exc_type, exc_val, exc_tb):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_33__exit__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_33__exit__ = {"__exit__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_33__exit__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_33__exit__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  CYTHON_UNUSED PyObject *__pyx_v_exc_type = 0;
  CYTHON_UNUSED PyObject *__pyx_v_exc_val = 0;
  CYTHON_UNUSED PyObject *__pyx_v_exc_tb = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_exc_type,&__pyx_mstate_global->__pyx_n_u_exc_val,&__pyx_mstate_global->__pyx_n_u_exc_tb,0};
  PyObject* values[4] = {0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2517, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(2, 2517, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 2517, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2517, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2517, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__exit__", 0) < (0)) __PYX_ERR(2, 2517, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 4, 4, i); __PYX_ERR(2, 2517, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 4)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2517, __pyx_L3_error)
      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 2517, __pyx_L3_error)
      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 2517, __pyx_L3_error)
      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(2, 2517, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
    __pyx_v_exc_type = values[1];
    __pyx_v_exc_val = values[2];
    __pyx_v_exc_tb = values[3];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__exit__", 1, 4, 4, __pyx_nargs); __PYX_ERR(2, 2517, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_32__exit__(__pyx_self, __pyx_v_self, __pyx_v_exc_type, __pyx_v_exc_val, __pyx_v_exc_tb);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_32__exit__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("questdb._client.QueryResult.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_33__exit__, 0, __pyx_mstate_global->__pyx_n_u_QueryResult___exit, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2517, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_exit, __pyx_t_15) < (0)) __PYX_ERR(2, 2517, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

+2518:         self.close()

  __pyx_t_2 = __pyx_v_self;
  __Pyx_INCREF(__pyx_t_2);
  __pyx_t_3 = 0;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
    __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_close, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2518, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+2519:         return False

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(Py_False);
  __pyx_r = Py_False;
  goto __pyx_L0;

 2520: 

+2521:     def __del__(self):

/* Python wrapper */
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_35__del__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyMethodDef __pyx_mdef_7questdb_7_client_11QueryResult_35__del__ = {"__del__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7questdb_7_client_11QueryResult_35__del__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7questdb_7_client_11QueryResult_35__del__(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_self = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 2521, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2521, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__del__", 0) < (0)) __PYX_ERR(2, 2521, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__del__", 1, 1, 1, i); __PYX_ERR(2, 2521, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 2521, __pyx_L3_error)
    }
    __pyx_v_self = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__del__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 2521, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("questdb._client.QueryResult.__del__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_7questdb_7_client_11QueryResult_34__del__(__pyx_self, __pyx_v_self);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_7questdb_7_client_11QueryResult_34__del__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
  struct __pyx_obj_7questdb_7_client__CursorHandle *__pyx_v_handle = 0;
  struct __pyx_obj_7questdb_7_client__ReaderHandle *__pyx_v_reader = 0;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("questdb._client.QueryResult.__del__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_handle);
  __Pyx_XDECREF((PyObject *)__pyx_v_reader);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_7questdb_7_client_11QueryResult_35__del__, 0, __pyx_mstate_global->__pyx_n_u_QueryResult___del, NULL, __pyx_mstate_global->__pyx_n_u_questdb__client, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 2521, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15);
  #endif
  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_del, __pyx_t_15) < (0)) __PYX_ERR(2, 2521, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;

 2522:         cdef _CursorHandle handle

 2523:         cdef _ReaderHandle reader

+2524:         try:

  {
    /*try:*/ {
/* … */
    }
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* … */
    __pyx_L5_except_error:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L7_try_return:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L0;
    __pyx_L4_exception_handled:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    __pyx_L8_try_end:;
  }

+2525:             handle = self._cursor_handle

      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cursor_handle_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2525, __pyx_L3_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_7questdb_7_client__CursorHandle))))) __PYX_ERR(2, 2525, __pyx_L3_error)
      __pyx_v_handle = ((struct __pyx_obj_7questdb_7_client__CursorHandle *)__pyx_t_4);
      __pyx_t_4 = 0;

+2526:             if not _cursor_handle_is_live(handle):

      __pyx_t_5 = __pyx_f_7questdb_7_client__cursor_handle_is_live(__pyx_v_handle); if (unlikely(__pyx_t_5 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 2526, __pyx_L3_error)
      __pyx_t_6 = (!__pyx_t_5);
      if (__pyx_t_6) {
/* … */
      }

+2527:                 return

        __Pyx_XDECREF(__pyx_r);
        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
        goto __pyx_L7_try_return;

+2528:             reader = handle._reader_ref

      __pyx_t_4 = ((PyObject *)__pyx_v_handle->_reader_ref);
      __Pyx_INCREF(__pyx_t_4);
      __pyx_v_reader = ((struct __pyx_obj_7questdb_7_client__ReaderHandle *)__pyx_t_4);
      __pyx_t_4 = 0;

+2529:             if reader is None or reader._must_close:

      __pyx_t_5 = (((PyObject *)__pyx_v_reader) == Py_None);
      if (!__pyx_t_5) {
      } else {
        __pyx_t_6 = __pyx_t_5;
        goto __pyx_L11_bool_binop_done;
      }
      __pyx_t_6 = __pyx_v_reader->_must_close;
      __pyx_L11_bool_binop_done:;
      if (__pyx_t_6) {
/* … */
      }

+2530:                 warnings.warn(

        __pyx_t_7 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_warnings); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2530, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_warn); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 2530, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_9);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 2531:                     'QueryResult was neither drained nor closed; its '

 2532:                     'pooled connection is being released by the garbage '

 2533:                     'collector. Use `with db.query(...)` or call '

 2534:                     '`close()`.',

+2535:                     ResourceWarning,

        __pyx_t_10 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_9))) {
          __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_9);
          assert(__pyx_t_7);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
          __Pyx_INCREF(__pyx_t_7);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
          __pyx_t_10 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_QueryResult_was_neither_drained, ((PyObject *)(((PyTypeObject*)PyExc_ResourceWarning)))};
          __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 2530, __pyx_L3_error)
          __Pyx_GOTREF(__pyx_t_8);
          if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_stacklevel, __pyx_mstate_global->__pyx_int_2, __pyx_t_8, __pyx_callargs+3, 0) < (0)) __PYX_ERR(2, 2530, __pyx_L3_error)
          __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_9, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
          __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
          if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2530, __pyx_L3_error)
          __Pyx_GOTREF(__pyx_t_4);
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 2536:                     stacklevel=2)

+2537:             self.close()

      __pyx_t_9 = __pyx_v_self;
      __Pyx_INCREF(__pyx_t_9);
      __pyx_t_10 = 0;
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL};
        __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_close, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
        if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 2537, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+2538:         except Exception:

    __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
    if (__pyx_t_11) {
      __Pyx_ErrRestore(0,0,0);
      goto __pyx_L4_exception_handled;
    }
    goto __pyx_L5_except_error;

 2539:             pass