Here's as far as I got with my initial prototype, in sqlite_utils/pandas.py:

```python from .db import Database as _Database, Table as _Table, View as _View import pandas as pd from typing import ( Iterable, Union, Optional, )

class Database(_Database): def query( self, sql: str, params: Optional[Union[Iterable, dict]] = None ) -> pd.DataFrame: return pd.DataFrame(super().query(sql, params))

def table(self, table_name: str, **kwargs) -> Union["Table", "View"]:
    "Return a table object, optionally configured with default options."
    klass = View if table_name in self.view_names() else Table
    return klass(self, table_name, **kwargs)

class PandasQueryable: def rows_where( self, where: str = None, where_args: Optional[Union[Iterable, dict]] = None, order_by: str = None, select: str = "*", limit: int = None, offset: int = None, ) -> pd.DataFrame: return pd.DataFrame( super().rows_where( where, where_args, order_by=order_by, select=select, limit=limit, offset=offset, ) )

class Table(PandasQueryable, _Table): pass

class View(PandasQueryable, _View): pass ```

We do a lot of df.to_sql() to write into sqlite, mostly in this moddule

It looks like the existing pd.read_sql_query() method has an optional dependency on SQLAlchemy:

``` ... import pandas as pd pd.read_sql_query(db.conn, "select * from articles")

ImportError: Using URI string without sqlalchemy installed.

Hah, no I was wrong about this: SQLAlchemy is not needed for SQLite to work, I just had the arguments the wrong way round:python pd.read_sql_query("select * from articles", db.conn)

Shows a DateFrame

```

I could teach .insert_all() and .upsert_all() to optionally accept a DataFrame. A challenge there is mypy - if Pandas is an optional dependency, is it possibly to declare types that accept a Union that includes DataFrame?

OK, so reading results from existing sqlite-utils into a Pandas DataFrame turns out to be trivial.

How about writing a DataFrame to a database table?

That feels like it could a lot more useful.

To be honest, I'm having second thoughts about this now mainly because the idiom for turning a generator of dicts into a DataFrame is SO simple:

python df = pd.DataFrame(db.query("select * from articles")) Given it's that simple, I'm questioning if there's any value to adding this to sqlite-utils at all. This likely becomes a documentation thing instead!

It looks like the existing pd.read_sql_query() method has an optional dependency on SQLAlchemy:

``` ... import pandas as pd pd.read_sql_query(db.conn, "select * from articles")

ImportError: Using URI string without sqlalchemy installed.

```

Requested feedback on Twitter here :https://twitter.com/simonw/status/1499927075930578948

Yeah, I imagine there are plenty of ways to do this with Pandas already - I'm opportunistically looking for a way to provide better integration with the rest of the Pandas situation from the work I've done in sqlite-utils already.

Might be that this isn't worth doing at all.

I haven't tried this, but it looks like Pandas has a method for this: https://pandas.pydata.org/docs/reference/api/pandas.read_sql_query.html

I'm not an experienced enough Pandas user to know if this design is right or not. I'm going to leave this open for a while and solicit some feedback.

I built a prototype of that second option and it looks pretty good:

Here's the pandas.py prototype:

```python from .db import Database as _Database, Table as _Table, View as _View import pandas as pd from typing import ( Iterable, Union, Optional, )

class Database(_Database): def query( self, sql: str, params: Optional[Union[Iterable, dict]] = None ) -> pd.DataFrame: return pd.DataFrame(super().query(sql, params))

def table(self, table_name: str, **kwargs) -> Union["Table", "View"]:
    "Return a table object, optionally configured with default options."
    klass = View if table_name in self.view_names() else Table
    return klass(self, table_name, **kwargs)

class PandasQueryable: def rows_where( self, where: str = None, where_args: Optional[Union[Iterable, dict]] = None, order_by: str = None, select: str = "*", limit: int = None, offset: int = None, ) -> pd.DataFrame: return pd.DataFrame( super().rows_where( where, where_args, order_by=order_by, select=select, limit=limit, offset=offset, ) )

class Table(PandasQueryable, _Table): pass

class View(PandasQueryable, _View): pass ```

I considered two ways of doing this.

First, have methods such as db.query_df() and table.rows_df which do the same as .query() and table.rows but return a DataFrame instead of a generator of dictionaries.

Second, have a compatibility class that is imported separately such as: python from sqlite_utils.pandas import Database Then have the .query() and .rows and other similar methods return dataframes.