add db type

this will be used to execute the correct sql for migrations.

Author: tarkah

sqlx-core/src/aurora/connection/mod.rs

@@ -1,4 +1,4 @@
-use crate::aurora::options::AuroraConnectOptions;
+use crate::aurora::options::{AuroraConnectOptions, AuroraDbType};
 use crate::aurora::statement::AuroraStatementMetadata;
 use crate::aurora::Aurora;
 use crate::common::StatementCache;
@@ -17,6 +17,7 @@ mod executor;
 
 /// A connection to an Aurora database.
 pub struct AuroraConnection {
+    pub(crate) db_type: AuroraDbType,
     pub(crate) resource_arn: String,
     pub(crate) secret_arn: String,
     pub(crate) database: Option<String>,
@@ -35,6 +36,10 @@ pub struct AuroraConnection {
 
 impl AuroraConnection {
     pub(crate) fn new(options: &AuroraConnectOptions) -> Result<Self, Error> {
+        let db_type = options
+            .db_type
+            .ok_or_else(|| Error::Configuration("db type not specified".into()))?;
+
         let region = options.region.parse().map_err(Error::config)?;
 
         let resource_arn = options
@@ -51,6 +56,7 @@ impl AuroraConnection {
         let client = RdsDataClient::new(region);
 
         Ok(Self {
+            db_type,
             resource_arn,
             secret_arn,
             database: options.database.clone(),

sqlx-core/src/aurora/options/mod.rs

@@ -1,11 +1,39 @@
+use crate::connection::LogSettings;
+use crate::error::Error;
+
 use std::env::var;
+use std::str::FromStr;
 
 mod connect;
 mod parse;
-use crate::connection::LogSettings;
+
+#[derive(Debug, Clone, Copy)]
+pub enum AuroraDbType {
+    MySQL,
+    Postgres,
+}
+
+impl FromStr for AuroraDbType {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let t = match s {
+            "mysql" => AuroraDbType::MySQL,
+            "postgres" => AuroraDbType::Postgres,
+            _ => {
+                return Err(Error::Configuration(
+                    "db type must be `postgres` or `mysql`".into(),
+                ))
+            }
+        };
+
+        Ok(t)
+    }
+}
 
 #[derive(Debug, Clone)]
 pub struct AuroraConnectOptions {
+    pub(crate) db_type: Option<AuroraDbType>,
     pub(crate) region: String,
     pub(crate) resource_arn: Option<String>,
     pub(crate) secret_arn: Option<String>,
@@ -23,6 +51,15 @@ impl Default for AuroraConnectOptions {
 
 impl AuroraConnectOptions {
     pub fn new() -> Self {
+        let db_type = match var("AURORA_DB_TYPE").map(|s| s.parse()) {
+            Ok(Ok(t)) => Some(t),
+            Ok(Err(e)) => {
+                log::error!("{}", e);
+                None
+            }
+            Err(_) => None,
+        };
+
         let region = var("AURORA_REGION")
             .ok()
             .unwrap_or_else(|| "us-east-1".to_owned());
@@ -31,6 +68,7 @@ impl AuroraConnectOptions {
         let secret_arn = var("AURORA_SECRET_ARN").ok();
 
         AuroraConnectOptions {
+            db_type,
             region,
             resource_arn,
             secret_arn,
@@ -41,6 +79,11 @@ impl AuroraConnectOptions {
         }
     }
 
+    pub fn db_type(mut self, db_type: AuroraDbType) -> Self {
+        self.db_type = Some(db_type);
+        self
+    }
+
     pub fn region(mut self, region: &str) -> Self {
         self.region = region.to_owned();
         self

sqlx-core/src/aurora/options/parse.rs

@@ -17,6 +17,9 @@ impl FromStr for AuroraConnectOptions {
                     options =
                         options.statement_cache_capacity(value.parse().map_err(Error::config)?);
                 }
+                "db-type" => {
+                    options = options.db_type(value.parse()?);
+                }
                 "region" => {
                     options = options.region(&*value);
                 }