fn default_mysql_port() -> u16 {

    DEFAULT_PORT

}

fn default_mysql_timeout() -> u64 {

    DEFAULT_TIMEOUT

}

    pub fn as_mysql_connect_options(&self) -> anyhow::Result<MySqlConnectOptions> {

        let mut options = MySqlConnectOptions::new()

            .database("mysql")

            .log_statements(tracing::log::LevelFilter::Trace);

        if let Some(username) = &self.username {

            options = options.username(username);

        }

        if let Some(password_file) = &self.password_file {

            let password = fs::read_to_string(password_file)

                .with_context(|| {

                    format!("Failed to read MySQL password file at {password_file:?}")

                })?

                .trim()

                .to_owned();

            options = options.password(&password);

        } else if let Some(password) = &self.password {

            options = options.password(password);

        }

        if let Some(socket_path) = &self.socket_path {

            options = options.socket(socket_path);

        } else if let Some(host) = &self.host {

            options = options.host(host);

            options = options.port(self.port);

        } else {

            anyhow::bail!("No MySQL host or socket path provided");

        Ok(options)

    }

    pub fn log_connection_notice(&self) {

        let mut display_config = self.to_owned();

        display_config.password = display_config

            .password

            .as_ref()

            .map(|_| "<REDACTED>".to_owned());

        tracing::debug!(

    }

    pub fn read_config_from_path(config_path: &Path) -> anyhow::Result<Self> {

        tracing::debug!("Reading config file at {:?}", config_path);

        fs::read_to_string(config_path)

            .context(format!("Failed to read config file at {config_path:?}"))

            .and_then(|c| toml::from_str(&c).context("Failed to parse config file"))

            .context(format!("Failed to parse config file at {config_path:?}"))

    }