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 ```

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'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.