QueueableCommand,

    ExecutableCommand, QueueableCommand,

pub async fn pick(db: AsyncConnection, count: u16) -> DynResult<()> {

pub async fn pick(db: &AsyncConnection, count: u16) -> DynResult<()> {
    let mut stderr = std::io::stderr();
    stderr.execute(cursor::Hide)?;
    let (mut input, done) = events();
    stderr.execute(cursor::Show)?;

    )?;
    conn.execute(
        "CREATE INDEX IF NOT EXISTS prefs_index ON preferences(better,worse)",
    )?;
    conn.execute(
        "CREATE INDEX IF NOT EXISTS prefs_better ON preferences(better)",

    conn.execute(
        "CREATE INDEX IF NOT EXISTS prefs_worse ON preferences(worse)",
    )?;

type DBFunction = Box<dyn for<'a> FnOnce(&'a sqlite::Connection) + Send>;

type DBFunction =
    Box<dyn for<'a> FnOnce(&'a sqlite::Connection) + Send + Sync + 'static>;

#[derive(Clone)]

    pub async fn add_name(&self, name: String) -> DynResult<i64> {
        match self

    pub async fn add_name(&self, name: String) -> DynResult<(i64, bool)> {
        Ok(self

                stmnt.next().ok();

                let is_new = stmnt.next().is_ok();

                    sqlite::State::Row => Ok(stmnt.read::<i64>(0)?),

                    sqlite::State::Row => Ok((stmnt.read::<i64>(0)?, is_new)),

                }
            })
            .await??)
    }
    pub async fn compare(
        &self,
        a: i64,
        b: i64,
    ) -> DynResult<Option<std::cmp::Ordering>> {
        if a == b {
            return Ok(Some(std::cmp::Ordering::Equal));
        }
        Ok(self.post(move |conn| -> DynResult<Option<std::cmp::Ordering>> {
            let mut stmnt = conn.prepare("SELECT better, worse FROM preferences WHERE (better = ? AND worse = ?) OR (better = ? AND worse = ?)")?;
            stmnt.bind::<i64>(1,a)?;
            stmnt.bind::<i64>(2,b)?;
            stmnt.bind::<i64>(3,b)?;
            stmnt.bind::<i64>(4,a)?;
            match stmnt.next()? {
                sqlite::State::Done => Ok(None),
                sqlite::State::Row => {
                    let better = stmnt.read::<i64>(0)?;
                    let worse = stmnt.read::<i64>(1)?;
                    if better == a && worse == b {
                        Ok(Some(std::cmp::Ordering::Greater))
                    } else if better == b && worse == a {
                        Ok(Some(std::cmp::Ordering::Less))
                    } else {
                        Ok(Some(std::cmp::Ordering::Equal))
                    }
                }
            }
        }).await??)
    }
    pub async fn list_names(&self) -> DynResult<Vec<(String, i64)>> {
        match self
            .post(|conn| {
                let mut stmnt =
                    conn.prepare("SELECT name, rowid FROM names")?;
                let mut rows = Vec::new();
                while let sqlite::State::Row = stmnt.next()? {
                    rows.push((
                        stmnt.read::<String>(0)?,
                        stmnt.read::<i64>(1)?,
                    ));

                Ok(rows)

            Ok(Err(e)) => Err(Box::new(e) as crate::DynError),

            Ok(Err(e)) => Err(e),

        }
    }
    async fn insert_preference(
        &self,
        better: i64,
        worse: i64,
    ) -> DynResult<()> {
        self.insert_one_preference(better, worse).await?;
        self.make_transitive().await
    }
    async fn insert_one_preference(
        &self,
        better: i64,
        worse: i64,
    ) -> DynResult<()> {
        self.post(move |db| -> DynResult<_> {
            let mut stmnt = db.prepare(
                "INSERT INTO preferences(better, worse) VALUES(?, ?)",
            )?;
            stmnt.bind::<i64>(1, better)?;
            stmnt.bind::<i64>(2, worse)?;
            stmnt.next()?;
            Ok(())
        })
        .await?
    }
    pub async fn make_transitive(&self) -> DynResult<()> {
        loop {
            let todo = self
                .post(|db| -> DynResult<_> {
                    let mut stmnt = db.prepare(
                        "SELECT a.better, b.worse
                FROM preferences AS a
                INNER JOIN preferences as b ON a.worse = b.better
                WHERE NOT EXISTS (
                  SELECT rowid FROM preferences AS x
                  WHERE x.better = a.better
                  AND x.worse = b.worse
                )
                ",
                    )?;
                    let mut rows = Vec::new();
                    while let sqlite::State::Row = stmnt.next()? {
                        rows.push((
                            stmnt.read::<i64>(0)?,
                            stmnt.read::<i64>(1)?,
                        ));
                    }
                    Ok(rows)
                })
                .await??;
            if todo.is_empty() {
                return Ok(());
            } else {
                let handles: Vec<_> = todo
                    .into_iter()
                    .map(|(better, worse)| {
                        let target = self.clone();
                        tokio::spawn(async move {
                            target.insert_one_preference(better, worse).await
                        })
                    })
                    .collect();
                for handle in handles {
                    handle.await??;
                }
            }

        F: FnOnce(&sqlite::Connection) -> U + Send + 'static,

        F: FnOnce(&sqlite::Connection) -> U + Send,

        let h = move |conn: &sqlite::Connection| {
            sc.send(cb(conn)).unwrap_or(());
        };

            .send(Box::new(move |conn: &sqlite::Connection| {
                sc.send(cb(conn)).unwrap_or(());

            .send(unsafe {
                std::mem::transmute::<_, DBFunction>(Box::new(h)
                    as Box<dyn for<'a> FnOnce(&'a sqlite::Connection) + Send>)

                as Box<dyn for<'a> FnOnce(&'a sqlite::Connection) + Send>)

            Self::Pick { count } => {}

            Self::Pick { count } => {
                pick::pick(db, *count).await?;
            }