use crate::adapters::duckdb::constants::{
EXTENSION_EXCEPTION, MOTHERDUCK_TOKEN_VARIABLES, MOTHERDUCK_UNSUPPORTED_DUCKDB,
};
use crate::adapters::duckdb::errors::DuckDbError;
use crate::auth::models::Secret;
use crate::project::constants::MOTHERDUCK_PREFIX;
use crate::project::main::motherduck_path::motherduck_path;
pub(in crate::adapters::duckdb) fn path_text(database: &str) -> Result<String, DuckDbError> {
let parts = motherduck_path(database);
if parts.options.to_ascii_lowercase().contains("token")
|| parts
.name
.is_some_and(|name| name.to_ascii_lowercase().contains("motherduck_token"))
{
return Err(DuckDbError::MotherDuck(
"a motherduck connection's database holds a token; set it in token instead".to_owned(),
));
}
let options = match parts.options {
"" => String::new(),
options => format!("?{options}"),
};
Ok(format!(
"{MOTHERDUCK_PREFIX}{}{options}",
parts.name.unwrap_or_default()
))
}
pub(in crate::adapters::duckdb) fn chosen_token(
token: Option<&Secret>,
variable: impl Fn(&str) -> Option<String>,
) -> Option<String> {
if let Some(token) = token {
return Some(token.expose().to_owned()).filter(|token| !token.is_empty());
}
for name in MOTHERDUCK_TOKEN_VARIABLES {
if let Some(token) = variable(name)
&& !token.is_empty()
{
return Some(token);
}
}
None
}
pub(in crate::adapters::duckdb) fn environment_variable(name: &str) -> Option<String> {
match std::env::var(name) {
Ok(value) => Some(value),
Err(std::env::VarError::NotPresent | std::env::VarError::NotUnicode(_)) => None,
}
}
pub(in crate::adapters::duckdb) fn connection_string(path: &str, token: &str) -> String {
let separator = match path.contains('?') {
true => '&',
false => '?',
};
format!("{path}{separator}motherduck_token={}", query_value(token))
}
pub(in crate::adapters::duckdb) fn refused(error: &str, token: &str, shown: &str) -> DuckDbError {
let error = error
.replace(&query_value(token), "<redacted>")
.replace(token, "<redacted>");
if !error.contains(MOTHERDUCK_UNSUPPORTED_DUCKDB) {
return DuckDbError::MotherDuck(format!("cannot open {shown}: {error}"));
}
let said = error
.rsplit_once(EXTENSION_EXCEPTION)
.map_or(error.as_str(), |(_, said)| said)
.trim_matches('"')
.split_whitespace()
.collect::<Vec<_>>()
.join(" ");
DuckDbError::MotherDuck(format!(
"cannot open {shown}: MotherDuck doesn't accept the DuckDB version this SQLLoad bundles yet, so no SQLLoad release can connect to it until it does. MotherDuck says: {said}"
))
}
fn query_value(value: &str) -> String {
let mut encoded = String::with_capacity(value.len());
for byte in value.bytes() {
match byte {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
encoded.push(char::from(byte));
}
byte => encoded.push_str(&format!("%{byte:02X}")),
}
}
encoded
}