feat: add full player listing command

src/commands/player.rs

@@ -34,16 +34,21 @@ fn player_display(
 }
 
 pub fn list(connection: &Connection, dataset: Option<String>, all: bool) {
-    if all {
-    } else {
-        let dataset = dataset.unwrap_or_else(|| String::from("default"));
+    let dataset = dataset.unwrap_or_else(|| String::from("default"));
+    let mut players = list_players(connection, if all { None } else { Some(&dataset) })
+        .expect("Error communicating with SQLite");
+
+    players.sort_by_cached_key(|data| data.name.clone());
+
+    for player in players {
+        player_display(player, true, false, true);
     }
 }
 
 pub fn info(connection: &Connection, dataset: Option<String>, player: String) {
     let dataset = dataset.unwrap_or_else(|| String::from("default"));
 
-    let player = get_player_from_input(connection, player)
+    let player = get_player_from_input(connection, &dataset, player)
         .unwrap_or_else(|_| error("Could not find player", 1));
 
     let (won, lost) = get_player_set_counts(connection, &dataset, player.id)
@@ -62,11 +67,11 @@ pub fn info(connection: &Connection, dataset: Option<String>, player: String) {
 pub fn matchup(connection: &Connection, dataset: Option<String>, player1: String, player2: String) {
     let dataset = dataset.unwrap_or_else(|| String::from("default"));
 
-    let player1 = get_player_from_input(connection, player1)
+    let player1 = get_player_from_input(connection, &dataset, player1)
         .unwrap_or_else(|_| error("Could not find player", 1));
     let id1 = player1.id;
 
-    let player2 = get_player_from_input(connection, player2)
+    let player2 = get_player_from_input(connection, &dataset, player2)
         .unwrap_or_else(|_| error("Could not find player", 1));
     let id2 = player2.id;
 

src/database.rs

@@ -317,8 +317,40 @@ pub fn get_all_players(connection: &Connection, dataset: &str) -> sqlite::Result
         .try_collect()
 }
 
-pub fn get_player(connection: &Connection, player: PlayerId) -> sqlite::Result<PlayerData> {
-    let query = "SELECT name, prefix, discrim FROM players WHERE id = ?";
+pub fn list_players(
+    connection: &Connection,
+    dataset: Option<&str>,
+) -> sqlite::Result<Vec<PlayerData>> {
+    let query = if let Some(dataset) = dataset {
+        format!(r#"SELECT * FROM "{}_players", players USING (id)"#, dataset,)
+    } else {
+        String::from(r#"SELECT * FROM players"#)
+    };
+
+    connection
+        .prepare(&query)?
+        .into_iter()
+        .map(|r| {
+            let r_ = r?;
+            Ok(PlayerData {
+                id: PlayerId(r_.read::<i64, _>("id") as u64),
+                name: String::from(r_.read::<&str, _>("name")),
+                prefix: r_.read::<Option<&str>, _>("prefix").map(String::from),
+                discrim: String::from(r_.read::<&str, _>("discrim")),
+            })
+        })
+        .try_collect()
+}
+
+pub fn get_player(
+    connection: &Connection,
+    dataset: &str,
+    player: PlayerId,
+) -> sqlite::Result<PlayerData> {
+    let query = format!(
+        r#"SELECT * FROM "{}_players", players USING (id) WHERE id = ?"#,
+        dataset
+    );
 
     let mut statement = connection.prepare(&query)?;
     statement.bind((1, player.0 as i64))?;
@@ -333,9 +365,13 @@ pub fn get_player(connection: &Connection, player: PlayerId) -> sqlite::Result<P
 
 pub fn get_player_from_discrim(
     connection: &Connection,
+    dataset: &str,
     discrim: &str,
 ) -> sqlite::Result<PlayerData> {
-    let query = "SELECT id, name, prefix FROM players WHERE discrim = ?";
+    let query = format!(
+        r#"SELECT * FROM "{}_players", players USING (id) WHERE discrim = ?"#,
+        dataset
+    );
 
     let mut statement = connection.prepare(&query)?;
     statement.bind((1, discrim))?;
@@ -348,8 +384,15 @@ pub fn get_player_from_discrim(
     })
 }
 
-pub fn match_player_name(connection: &Connection, name: &str) -> sqlite::Result<Vec<PlayerData>> {
-    let query = "SELECT * FROM players WHERE name LIKE ?";
+pub fn match_player_name(
+    connection: &Connection,
+    dataset: &str,
+    name: &str,
+) -> sqlite::Result<Vec<PlayerData>> {
+    let query = format!(
+        r#"SELECT * FROM "{}_players", players USING (id) WHERE name LIKE ?"#,
+        dataset
+    );
 
     connection
         .prepare(&query)?

src/main.rs

@@ -98,6 +98,11 @@ enum DatasetSC {
 
 #[derive(Subcommand)]
 enum PlayerSC {
+    #[command(about = "List all players in a dataset")]
+    List {
+        #[arg(short, long, help = "List all players ever recorded")]
+        all: bool,
+    },
     #[command(about = "Get info about a player")]
     Info { player: String },
     #[command(about = "Matchup data between two players")]
@@ -134,6 +139,10 @@ fn main() {
             subcommand: DatasetSC::Rename { old, new },
         } => dataset::rename(&connection, old, new),
 
+        Subcommands::Player {
+            subcommand: PlayerSC::List { all },
+            dataset,
+        } => player::list(&connection, dataset, all),
         Subcommands::Player {
             subcommand: PlayerSC::Info { player },
             dataset,

src/util.rs

@@ -80,12 +80,16 @@ pub fn parse_player_input(input: String) -> PlayerInput {
     }
 }
 
-pub fn get_player_from_input(connection: &Connection, input: String) -> sqlite::Result<PlayerData> {
+pub fn get_player_from_input(
+    connection: &Connection,
+    dataset: &str,
+    input: String,
+) -> sqlite::Result<PlayerData> {
     match parse_player_input(input) {
-        PlayerInput::Id(id) => get_player(connection, id),
-        PlayerInput::Discrim(discrim) => get_player_from_discrim(connection, &discrim),
+        PlayerInput::Id(id) => get_player(connection, dataset, id),
+        PlayerInput::Discrim(discrim) => get_player_from_discrim(connection, dataset, &discrim),
         PlayerInput::Name(name) => {
-            let players = match_player_name(connection, &name)?;
+            let players = match_player_name(connection, dataset, &name)?;
 
             if players.is_empty() {
                 error(&format!("Player {:?} not found", name), 1);