Method _g_copy_with_stats

tables/vlarray.py:854–905

Private part of Leaf.copy() for each kind of leaf.

(
        self,
        group: Group,
        name: str,
        start: int,
        stop: int,
        step: int,
        title: str,
        filters: Filters | None,
        chunkshape: tuple[int, ...] | None,
        _log: bool,
        **kwargs,
    )

        return rows

    def _g_copy_with_stats(
        self,
        group: Group,
        name: str,
        start: int,
        stop: int,
        step: int,
        title: str,
        filters: Filters | None,
        chunkshape: tuple[int, ...] | None,
        _log: bool,
        **kwargs,
    ) -> tuple[VLArray, int]:
        """Private part of Leaf.copy() for each kind of leaf."""
        # Build the new VLArray object
        obj = VLArray(
            group,
            name,
            self.atom,
            title=title,
            filters=filters,
            expectedrows=self._v_expectedrows,
            chunkshape=chunkshape,
            _log=_log,
        )

        # Now, fill the new vlarray with values from the old one
        # This is not buffered because we cannot forsee the length
        # of each record. So, the safest would be a copy row by row.
        # In the future, some analysis can be done in order to buffer
        # the copy process.
        nrowsinbuf = 1
        start, stop, step = self._process_range_read(start, stop, step)
        # Optimized version (no conversions, no type and shape checks, etc...)
        nrowscopied = SizeType(0)
        nbytes = 0
        if not hasattr(self.atom, "size"):  # it is a pseudo-atom
            atomsize = self.atom.base.size
        else:
            atomsize = self.atom.size
        for start2 in range(start, stop, step * nrowsinbuf):
            # Save the records on disk
            stop2 = start2 + step * nrowsinbuf
            if stop2 > stop:
                stop2 = stop
            nparr = self._read_array(start=start2, stop=stop2, step=step)[0]
            nobjects = nparr.shape[0]
            obj._append(nparr, nobjects)
            nbytes += nobjects * atomsize
            nrowscopied += 1
        obj.nrows = nrowscopied
        return (obj, nbytes)

    def __repr__(self) -> str:
        """`VLArray` string representation.