Rust + Iced - Run code when app starts

1

I have a Rust app that utilizes Iced for the GUI. It works. On the main screen I have a button which sends a message to the Iced update function. The code associated with this message runs code that updates an SQLite database which in turn allows me to update 3 state variables. How can I run this code when the app starts instead of having to click a button? I was unsure what code to include so below is the implementation code for the State struct.

impl State {

    fn new() -> Self {
        Self {
            records_read: 0,
            records_inserted: 0,
            records_updated: 0,
            screen: Screen::HomeScreen,
            closing_values: Vec::new(),
        }
    }

    fn update(&mut self, msg: Message) -> Task<Message> {

        match msg {

            Message::Exit => {
                std::process::exit(0);
            }

            Message::GoToHomeScreen => {
                self.screen = Screen::HomeScreen;
                self.records_read = 0;
                self.records_inserted = 0;
                Task::none()
            }

            Message::GoToUpdateDataBaseScreen => {
                self.screen = Screen::UpdateDatabaseScreen;

                let record_data = match insert_csv_data_into_db() {
                    Ok(data) => {
                        data
                    },
                    Err(e) => {
                        if let IoSqlError::IoError(io_err) = e {
                            println!("I/O error details: {}", io_err);
                        } else if let IoSqlError::SqlError(sql_err) = e {
                            println!("SQL error details: {}", sql_err);
                        }
                        return Task::none();
                    }
                };

                self.records_read = record_data[0];
                self.records_inserted = record_data[1];
                self.records_updated = record_data[2];
                Task::none()
            }

            Message::GoToMinCloseScreen => {

                self.screen = Screen::MinCloseScreen;

                let query_results = match get_close(QueryType::Min) {
                    Ok(results) => results,
                    Err(e) => {
                        if let IoSqlError::IoError(io_err) = e {
                            println!("I/O error details: {}", io_err);
                        } else if let IoSqlError::SqlError(sql_err) = e {
                            println!("SQL error details: {}", sql_err);
                        }
                        return Task::none();
                    }
                };

                self.closing_values = query_results;
                Task::none()
            }

            Message::GoToMaxCloseScreen => {

                self.screen = Screen::MaxCloseScreen;

                let query_results = match get_close(QueryType::Max) {
                    Ok(results) => results,
                    Err(e) => {
                        if let IoSqlError::IoError(io_err) = e {
                            println!("I/O error details: {}", io_err);
                        } else if let IoSqlError::SqlError(sql_err) = e {
                            println!("SQL error details: {}", sql_err);
                        }
                        return Task::none();
                    }
                };

                self.closing_values = query_results;
                Task::none()
            }
        } // end of match statement
    }

    fn view(&self) -> iced::Element<'_, Message> {

        match self.screen {

            Screen::HomeScreen => {
                home_view()
            } 

            Screen::UpdateDatabaseScreen => {
                update_db_view(self.records_read, self.records_inserted, self.records_updated)
            } 

            Screen::MinCloseScreen => {
                min_max_close_view("Min", self.closing_values.as_ref())
            } 

            Screen::MaxCloseScreen => {
                min_max_close_view("Max", self.closing_values.as_ref())
            } 

        } 
    } 
}
2

You can just run any code you like in State::new, so you can just run insert_csv_data_into_db() in new, no?

3

I had not thought of that. Will try tomorrow and report. Thank you.

4

Below is the update State::new code. This works. I also removed the code in the update function associated with updating the database and its associated button, since it is now performed when the app is started.
Thank you for the assistance.

    fn new() -> Self {

        let record_data = match insert_csv_data_into_db() {
            Ok(data) => {
                data
            },
            Err(e) => {
                if let IoSqlError::IoError(io_err) = e {
                    println!("I/O error details: {}", io_err);
                } else if let IoSqlError::SqlError(sql_err) = e {
                    println!("SQL error details: {}", sql_err);
                }
                return Self {
                    records_read: 0,
                    records_inserted: 0,
                    records_updated: 0,
                    screen: Screen::HomeScreen,
                    closing_values: Vec::new(),
                };
            }
        };

        Self {
            records_read: record_data[0],
            records_inserted: record_data[1],
            records_updated: record_data[2],
            screen: Screen::UpdateDatabaseScreen,
            closing_values: Vec::new(),
        }

    }