sqlxo 0.9.1

#![forbid(unsafe_code)]
#![feature(specialization)]
#![feature(inherent_associated_types)]
#![allow(incomplete_features)]
extern crate self as sqlxo;

pub use smallvec;
pub use sqlxo_macros::*;
pub use sqlxo_traits::*;

pub mod prelude {
	pub use super::{
		Filterable,
		JoinKind,
		Query,
		QueryContext,
		Sortable,
		SqlJoin,
		WebQuery,
	};
}

pub mod blocks;
pub mod error;
pub mod fts;
pub mod select;
pub mod web;

mod delete;
mod insert;
mod read;
mod update;
use crate::blocks::Expression;
pub use delete::{
	DeleteQueryBuilder,
	DeleteQueryPlan,
};
pub use insert::{
	InsertQueryBuilder,
	InsertQueryPlan,
};
pub use read::{
	ReadQueryBuilder,
	ReadQueryPlan,
	RelationReloadBuilder,
};
pub use select::{
	Column,
	SelectionList,
};
pub use update::{
	UpdateQueryBuilder,
	UpdateQueryPlan,
};
pub use web::{
	WebDeleteFilter,
	WebExpression,
	WebFilter,
	WebQueryError,
	WebReadFilter,
	WebSort,
	WebUpdateFilter,
};

use sqlx::{
	Executor,
	Postgres,
};

pub struct QueryBuilder<C> {
	_phantom: std::marker::PhantomData<C>,
}

impl<'a, C> QueryBuilder<C>
where
	C: QueryContext,
{
	pub fn read() -> ReadQueryBuilder<'a, C> {
		ReadQueryBuilder::from_ctx()
	}

	pub fn delete() -> DeleteQueryBuilder<'a, C>
	where
		C::Model: crate::Deletable,
	{
		DeleteQueryBuilder::from_ctx()
	}

	pub fn update() -> UpdateQueryBuilder<'a, C>
	where
		C::Model: crate::Updatable,
	{
		UpdateQueryBuilder::from_ctx()
	}

	pub fn insert() -> InsertQueryBuilder<'a, C>
	where
		C::Model: crate::Creatable,
	{
		InsertQueryBuilder::from_ctx()
	}

	pub fn reload_relations_one<'m>(
		model: &'m mut C::Model,
	) -> RelationReloadBuilder<'m, C>
	where
		C::Model: crate::PrimaryKeyExpression<C>,
	{
		RelationReloadBuilder::one(model)
	}

	pub fn reload_relations_many<'m>(
		models: &'m mut [C::Model],
	) -> RelationReloadBuilder<'m, C>
	where
		C::Model: crate::PrimaryKeyExpression<C>,
	{
		RelationReloadBuilder::many(models)
	}
}

pub trait PrimaryKeyExpression<C: QueryContext> {
	fn primary_key_expression(&self) -> Expression<C::Query>;
}

#[async_trait::async_trait]
pub trait ExecutablePlan<C: QueryContext> {
	async fn execute<'e, E>(&self, exec: E) -> Result<u64>
	where
		E: Executor<'e, Database = Postgres>;
}

#[async_trait::async_trait]
pub trait FetchablePlan<C: QueryContext, Row> {
	async fn fetch_one<'e, E>(&self, exec: E) -> Result<Row>
	where
		E: Executor<'e, Database = Postgres>;

	async fn fetch_all<'e, E>(&self, exec: E) -> Result<Vec<Row>>
	where
		E: Executor<'e, Database = Postgres>;

	async fn fetch_optional<'e, E>(&self, exec: E) -> Result<Option<Row>>
	where
		E: Executor<'e, Database = Postgres>;
}

pub trait Planable<C, Row>: ExecutablePlan<C> + FetchablePlan<C, Row>
where
	C: QueryContext,
{
}

pub trait Buildable<C: QueryContext> {
	type Row;
	type Plan: Planable<C, Self::Row>;

	fn from_ctx() -> Self;
	fn build(self) -> Self::Plan;
}