Method next

crates/stdlib/src/_sqlite3.rs:2078–2195

(zelf: &Py<Self>, vm: &VirtualMachine)

    impl SelfIter for Cursor {}
    impl IterNext for Cursor {
        fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
            // Check if connection is closed first, and if so, clear statement to release file lock
            if zelf.connection.is_closed() {
                let mut guard = zelf.inner.lock();
                if let Some(stmt) = guard.as_mut().and_then(|inner| inner.statement.take()) {
                    stmt.lock().reset();
                }
                return Err(new_programming_error(
                    vm,
                    "Cannot operate on a closed database.".to_owned(),
                ));
            }

            let mut inner = zelf.inner(vm)?;
            let Some(stmt) = &inner.statement else {
                return Ok(PyIterReturn::StopIteration(None));
            };
            let st = stmt.lock();
            let db = zelf.connection.db_lock(vm)?;
            // fetch_one_row

            let num_cols = st.data_count();

            let mut row = Vec::with_capacity(num_cols as usize);

            for i in 0..num_cols {
                let val = if let Some(converter) =
                    inner.row_cast_map.get(i as usize).cloned().flatten()
                {
                    let blob = st.column_blob(i);
                    if blob.is_null() {
                        vm.ctx.none()
                    } else {
                        let nbytes = st.column_bytes(i);
                        let blob = unsafe {
                            core::slice::from_raw_parts(blob.cast::<u8>(), nbytes as usize)
                        };
                        let blob = vm.ctx.new_bytes(blob.to_vec());
                        converter.call((blob,), vm)?
                    }
                } else {
                    let col_type = st.column_type(i);
                    match col_type {
                        SQLITE_NULL => vm.ctx.none(),
                        SQLITE_INTEGER => vm.ctx.new_int(st.column_int(i)).into(),
                        SQLITE_FLOAT => vm.ctx.new_float(st.column_double(i)).into(),
                        SQLITE_TEXT => {
                            let text =
                                ptr_to_vec(st.column_text(i), st.column_bytes(i), db.db, vm)?;

                            let text_factory = zelf.connection.text_factory.to_owned();

                            if text_factory.is(PyStr::class(&vm.ctx)) {
                                let text = String::from_utf8(text).map_err(|err| {
                                    let col_name = st.column_name(i);
                                    let col_name_str = ptr_to_str(col_name, vm).unwrap_or("?");
                                    let valid_up_to = err.utf8_error().valid_up_to();
                                    let text_prefix = String::from_utf8_lossy(&err.as_bytes()[..valid_up_to]);