How can I add a text input and a button to call a new query in this app?
To add a text input and a button to call a new query in your app, you need to follow these steps:

1. **Add `tui-textarea` for input handling.**
2. **Create a function to handle new queries and update the state accordingly.**
3. **Render the input field and the button in your terminal UI.**
4. **Handle user input to collect the query and execute it when the button is pressed.**

Let's apply these changes step-by-step.

### 1. Add `tui-textarea` Dependency
Here's the `Cargo.toml`:

```edit squealer/Cargo.toml
tui-textarea = "0.4.0"
---
tui-textarea = "0.4.0"
crossterm = "0.27.0"
ratatui = "0.26.0"
sqlx = {version="0.7.4", features=["runtime-tokio-native-tls", "sqlite"]}
tokio = { version = "1.20.0", features = ["macros", "rt-multi-thread"] }
tui-textarea = "0.4.0"
```

Here, you're simply ensuring that the `tui-textarea` dependency is included.

### 2. Handle User Input for New Query
You need to create a function to handle new queries and update the state accordingly. Integrating text input and button press updates:

```edit squealer/src/main.rs
use crossterm::{
    event::{self, DisableMouseCapture, EnableMouseCapture, KeyCode, KeyEvent},
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use ratatui::{
    backend::CrosstermBackend,
    widgets::{Block, Borders, Cell, Row as TableRow, Table, TableState},
    Terminal,
};
use sqlx::{
    sqlite::{SqlitePool, SqliteRow},
    Column, Pool,
};
use sqlx::{Row, Sqlite};
use std::{error::Error, io, thread, time::Duration};
use tokio;
use tui_textarea::{TextArea, Input};

struct AppState {
    pool: Option<Pool<Sqlite>>,
    results: Option<Vec<SqliteRow>>,
    query_input: TextArea,
}

impl Default for AppState {
    fn default() -> Self {
        let mut query_input = TextArea::default();
        query_input.set_block(Block::default().borders(Borders::ALL).title("Query"));
        Self {
            pool: None,
            results: None,
            query_input,
        }
    }
}
---
use crossterm::{
    event::{self, DisableMouseCapture, EnableMouseCapture, KeyCode},
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use ratatui::{
    backend::CrosstermBackend,
    widgets::{Block, Borders, Cell, Row as TableRow, Table, TableState},
    Terminal,
};
use sqlx::{
    sqlite::{SqlitePool, SqliteRow},
    Column, Pool,
};
use sqlx::{Row, Sqlite};
use std::{error::Error, io, thread, time::Duration};
use tokio;
use tui_textarea::{TextArea, Input};

struct AppState {
    pool: Option<Pool<Sqlite>>,
    results: Option<Vec<SqliteRow>>,
    query_input: TextArea,
}

impl Default for AppState {
    fn default() -> Self {
        let mut query_input = TextArea::default();
        query_input.set_block(Block::default().borders(Borders::ALL).title("Query"));
        Self {
            pool: None,
            results: None,
            query_input,
        }
    }
}
```

### 3. Modify the Main Function

You need to modify your `main` function to render the input field and listen for button presses.

```edit squealer/src/main.rs
    // Example dynamic query
    let query = "SELECT id, name, email FROM users"; // This could be provided at runtime

    // Fetch the results
    app.results = match app.pool {
        None => None,
        Some(ref pool) => Some(sqlx::query(query).fetch_all(pool).await?),
    };

    // Prepare the data for the table
    let (headers, data) = match app.results {
        None => return Err("No results to display".into()),
        Some(ref rows) => {
            let headers = rows
                .first()
                .map(|row| {
                    row.columns()
                        .iter()
                        .map(|col| col.name().to_string())
                        .collect::<Vec<_>>()
                })
                .unwrap_or_default();
            let data = rows
                .iter()
                .map(|row| {
                    (0..row.len())
                        .map(|i| row.try_get::<&str, _>(i).unwrap_or_default().to_string())
                        .collect::<Vec<_>>()
                })
                .collect::<Vec<_>>();
            (headers, data)
        }
    };

    // Create table state
    let mut table_state = TableState::default();
---
    loop {
        // Render the input field and table
        terminal.draw(|f| {
            let size = f.size();
            let chunks = Layout::default()
                .direction(Direction::Vertical)
                .margin(1)
                .constraints(
                    [
                        Constraint::Length(3),
                        Constraint::Min(1),
                    ]
                    .as_ref(),
                )
                .split(size);

            // Render input field
            f.render_widget(app.query_input.widget(), chunks[0]);

            // Render table
            render_table(f, chunks[1], &headers, &data, &mut table_state);
        })?;

        // Handle user input
        if let Event::Key(key) = event::read()? {
            match key.code {
                KeyCode::Char('q') => {
                    // Query is executed when 'q' is pressed
                    execute_query(&mut app).await?;
                }
                KeyCode::Esc => break,
                _ => {}
            }
        }
    }

    // restore terminal
    disable_raw_mode()?;
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        DisableMouseCapture
    )?;
    terminal.show_cursor()?;
```

### 4. Execute New Query

You need to create a new function to execute the new queries and update the state.

```edit squealer/src/main.rs
async fn init_database(pool: &sqlx::Pool<Sqlite>) -> Result<(), Box<dyn Error>> {
    let init_query = "
        CREATE TABLE users (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            email TEXT NOT NULL UNIQUE
        );
        INSERT INTO users (name, email) VALUES ('Alice', 'temp@email.com')
        ";

    sqlx::query(init_query).execute(pool).await?;

    Ok(())
}
---
async fn init_database(pool: &sqlx::Pool<Sqlite>) -> Result<(), Box<dyn Error>> {
    let init_query = "
        CREATE TABLE users (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            email TEXT NOT NULL UNIQUE
        );
        INSERT INTO users (name, email) VALUES ('Alice', 'temp@email.com')
        ";

    sqlx::query(init_query).execute(pool).await?;

    Ok(())
}

/// Execute a query from the input field and update the results.
async fn execute_query(app: &mut AppState) -> Result<(), Box<dyn Error>> {
    let query = app.query_input.lines().join(" ");
    if let Some(ref pool) = app.pool {
        app.results = Some(sqlx::query(&query).fetch_all(pool).await?);
    }
    Ok(())
}
```

### 5. Helper for Table Rendering

Finally, you need a helper method to render tables:

```edit squealer/src/main.rs
```
terminal.draw(|f| {
    let size = f.size();
    f.render_stateful_widget(table, size, &mut table_state);
})?;
---
fn render_table<B: Backend>(
    frame: &mut Frame<B>,
    area: Rect,
    headers: &[String],
    data: &[Vec<String>],
    state: &mut TableState,
) {
    let rows = data.iter().map(|row| {
        TableRow::new(
            row.iter()
                .map(|cell| Cell::from(cell.as_str()))
                .collect::<Vec<_>>(),
        )
    });

    let table = Table::new(rows, [15, 20, 30])
        .header(TableRow::new(
            headers
                .iter()
                .map(|h| Cell::from(h.as_str()))
                .collect::<Vec<_>>(),
        ))
        .block(Block::default().title("SQL Results").borders(Borders::ALL))
        .highlight_symbol(">>");

    frame.render_stateful_widget(table, area, state);
}
```

Putting all these together ensures that:
1. Your app state maintains the current text input.
2. The main function renders the input field and listens for a specific key (here 'q') to run the query.
3. Any new results are fetched and displayed in the table when a new query is executed.