pd.read_sql_query with chunksize: pandasSQL_builder should only be called when first chunk is requested
#### Code Sample
```python
        pool = mp.Pool(processes=None, initializer=_initialize_mp_preprocess)
        for vals in pool.imap_unordered(self._preprocess_chunk,
                                        pd.read_sql_query(
                                            query,
                                            url,
                                            chunksize=nlp_chunksize)):
```
#### Problem description
Using `pd.read_sql_query` with chunksize, sqlite and with the multiprocessing module currently fails, as `pandasSQL_builder` is called on execution of `pd.read_sql_query`, but the multiprocessing module requests the chunks in a different Thread (and the generated sqlite connection only wants to be used in the thread where it was created so it throws an Exception.). 

#### Workaround
Create a wrapper around `pd.read_sql_query` that only calls `pd.read_sql_query` once the first chunk is requested. Therefore `pandasSQL_builder` will be called within the Thread requesting the chunks.
```python
@attr.s(auto_attribs=True)
class PDSQLQueryWrapper:
    """Wrap the iterator.

    To create the db engine in the thread that calls the iterator first.

    """

    _read_sql_query_iterator = None

    query: str
    url: str
    chunksize: int

    def __iter__(self):
        return self

    def __next__(self):
        if self._read_sql_query_iterator is None:
            self._read_sql_query_iterator = pd.read_sql_query(
                self.query, self.url, chunksize=self.chunksize)

        return next(self._read_sql_query_iterator)

```

I believe pandas should play nicely with the python multiprocessing module, delaying the creation of the sqlite connection and thereby fixing this issue.