class BaseDAO(Generic[Model]):
    def __init__(self, model: Type[Model], session: AsyncSession):
        self.model = model
        self.session = session
    ...
    async def get_all_by_chunk(self, chunk_size=10_000):
        result = await self.session.execute(
            select(self.model).yield_per(chunk_size)
        )
        async for row in result.scalars():
            yield row

    async def get_iterator(self, *whereclauses, chunk_size: int=10_000):
        stmt = select(self.model)
        if whereclauses:
            stmt = stmt.where(*whereclauses)
        result = await (self.session.stream(stmt.execution_options(yield_per=chunk_size)))
        return result.scalars()

    async def get_many(self, *whereclauses, options: Iterable | ExecutableOption = None, limit: int = None,
                       offset: int = None, order_by=None):
        stmt = select(self.model)
    
        if whereclauses:
            stmt = stmt.where(*whereclauses)
        if options:
            if isinstance(options, ExecutableOption):
                stmt = stmt.options(options)
            elif isinstance(options, Iterable):
                stmt = stmt.options(*options)
        if limit:
            stmt = stmt.limit(limit)
        if offset:
            stmt = stmt.offset(offset)
        if order_by:
            stmt = stmt.order_by(order_by)
        result = await self.session.execute(stmt)
        return result.scalars().all()
    
    async def get_chunk_iterator(self, *whereclauses, chunk_size: int):
        offset = 0  # Start from the beginning
    
        while True:
            # Get the next batch of records
            records = await self.get_many(*whereclauses, limit=chunk_size, offset=offset, order_by=self.model.id)
    
            # If no more records, stop
            if not records:
                break
    
            # Yield the records
            yield records
    
            # Update the offset for the next batch
            offset += chunk_size
update! order_by is necessarily