use type_bridge_orm::{AnswerCancellation, QueryExecutionResourceLimits};
use crate::Result;
use crate::query::QuerySession;
use crate::remote::{ProxyConnectionPolicy, ProxyDatabase};
use crate::schema::Schema;
use crate::session::Database;
#[derive(Debug)]
pub enum ConnectionPolicy {
#[cfg(feature = "typedb")]
Direct(type_bridge_orm::DirectConnectionPolicy),
Proxy(ProxyConnectionPolicy),
}
#[cfg(feature = "typedb")]
impl From<type_bridge_orm::DirectConnectionPolicy> for ConnectionPolicy {
fn from(policy: type_bridge_orm::DirectConnectionPolicy) -> Self {
Self::Direct(policy)
}
}
impl From<ProxyConnectionPolicy> for ConnectionPolicy {
fn from(policy: ProxyConnectionPolicy) -> Self {
Self::Proxy(policy)
}
}
pub enum Connection<S: Schema> {
Direct(Database<S>),
Proxy(ProxyDatabase<S>),
}
impl<S: Schema> std::fmt::Debug for Connection<S> {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str(match self {
Self::Direct(_) => "Connection::Direct",
Self::Proxy(_) => "Connection::Proxy",
})
}
}
impl<S: Schema> Connection<S> {
pub fn query(&self) -> Result<QuerySession<'_, S>> {
self.query_with_resources(
QueryExecutionResourceLimits::default(),
AnswerCancellation::default(),
)
}
pub fn query_with_resources(
&self,
resources: QueryExecutionResourceLimits,
cancellation: AnswerCancellation,
) -> Result<QuerySession<'_, S>> {
match self {
Self::Direct(database) => database.query_with_resources(resources, cancellation),
Self::Proxy(proxy) => proxy.query_with_resources(resources, cancellation),
}
}
}