Lines
0 %
Functions
use std::collections::BTreeMap;
use sqlx::MySqlConnection;
use sqlx::prelude::*;
use serde::{Deserialize, Serialize};
use crate::core::types::MySQLDatabase;
use crate::{
core::{
common::UnixUser,
protocol::{
CreateDatabaseError, CreateDatabasesResponse, DropDatabaseError, DropDatabasesResponse,
ListAllDatabasesError, ListAllDatabasesResponse, ListDatabasesError,
ListDatabasesResponse,
},
server::{
common::create_user_group_matching_regex,
input_sanitization::{quote_identifier, validate_name, validate_ownership_by_unix_user},
};
// NOTE: this function is unsafe because it does no input validation.
pub(super) async fn unsafe_database_exists(
database_name: &str,
connection: &mut MySqlConnection,
) -> Result<bool, sqlx::Error> {
let result =
sqlx::query("SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?")
.bind(database_name)
.fetch_optional(connection)
.await;
if let Err(err) = &result {
log::error!(
"Failed to check if database '{}' exists: {:?}",
&database_name,
err
);
}
Ok(result?.is_some())
pub async fn create_databases(
database_names: Vec<MySQLDatabase>,
unix_user: &UnixUser,
) -> CreateDatabasesResponse {
let mut results = BTreeMap::new();
for database_name in database_names {
if let Err(err) = validate_name(&database_name) {
results.insert(
database_name.to_owned(),
Err(CreateDatabaseError::SanitizationError(err)),
continue;
if let Err(err) = validate_ownership_by_unix_user(&database_name, unix_user) {
Err(CreateDatabaseError::OwnershipError(err)),
match unsafe_database_exists(&database_name, &mut *connection).await {
Ok(true) => {
Err(CreateDatabaseError::DatabaseAlreadyExists),
Err(err) => {
Err(CreateDatabaseError::MySqlError(err.to_string())),
_ => {}
sqlx::query(format!("CREATE DATABASE {}", quote_identifier(&database_name)).as_str())
.execute(&mut *connection)
.await
.map(|_| ())
.map_err(|err| CreateDatabaseError::MySqlError(err.to_string()));
log::error!("Failed to create database '{}': {:?}", &database_name, err);
results.insert(database_name, result);
results
pub async fn drop_databases(
) -> DropDatabasesResponse {
Err(DropDatabaseError::SanitizationError(err)),
Err(DropDatabaseError::OwnershipError(err)),
Ok(false) => {
Err(DropDatabaseError::DatabaseDoesNotExist),
Err(DropDatabaseError::MySqlError(err.to_string())),
sqlx::query(format!("DROP DATABASE {}", quote_identifier(&database_name)).as_str())
.map_err(|err| DropDatabaseError::MySqlError(err.to_string()));
log::error!("Failed to drop database '{}': {:?}", &database_name, err);
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DatabaseRow {
pub database: MySQLDatabase,
impl FromRow<'_, sqlx::mysql::MySqlRow> for DatabaseRow {
fn from_row(row: &sqlx::mysql::MySqlRow) -> Result<Self, sqlx::Error> {
Ok(DatabaseRow {
database: row.try_get::<String, _>("database")?.into(),
})
pub async fn list_databases(
) -> ListDatabasesResponse {
Err(ListDatabasesError::SanitizationError(err)),
Err(ListDatabasesError::OwnershipError(err)),
let result = sqlx::query_as::<_, DatabaseRow>(
r#"
SELECT `SCHEMA_NAME` AS `database`
FROM `information_schema`.`SCHEMATA`
WHERE `SCHEMA_NAME` = ?
"#,
)
.bind(database_name.to_string())
.fetch_optional(&mut *connection)
.map_err(|err| ListDatabasesError::MySqlError(err.to_string()))
.and_then(|database| {
database
.map(Ok)
.unwrap_or_else(|| Err(ListDatabasesError::DatabaseDoesNotExist))
});
log::error!("Failed to list database '{}': {:?}", &database_name, err);
pub async fn list_all_databases_for_user(
) -> ListAllDatabasesResponse {
WHERE `SCHEMA_NAME` NOT IN ('information_schema', 'performance_schema', 'mysql', 'sys')
AND `SCHEMA_NAME` REGEXP ?
.bind(create_user_group_matching_regex(unix_user))
.fetch_all(connection)
.map_err(|err| ListAllDatabasesError::MySqlError(err.to_string()));
"Failed to list databases for user '{}': {:?}",
unix_user.username,
result