caisin/sea-orm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replacing Syntax & *BuilderBackend with DatabaseBackend

Browse Source
This commit is contained in:
Billy Chan 2021-07-15 16:27:22 +08:00 committed by Chris Tsang
parent 56fd77eddf
commit e83cc63e3a
23 changed files with 223 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
sea-orm-codegen/tests/mod.rs
View File

@ -2,7 +2,7 @@ mod entity;
use entity::*;
use sea_orm::{entity::*, error::*, MockDatabase, MockExecResult, Syntax, Transaction};
use sea_orm::{entity::*, error::*, DatabaseBackend, MockDatabase, MockExecResult, Transaction};
#[async_std::test]
async fn test_insert() -> Result<(), DbErr> {
@ -11,7 +11,7 @@ async fn test_insert() -> Result<(), DbErr> {
rows_affected: 1,
};
let db = MockDatabase::new(Syntax::Postgres)
let db = MockDatabase::new(DatabaseBackend::Postgres)
.append_exec_results(vec![exec_result.clone()])
.into_connection();
@ -27,7 +27,7 @@ async fn test_insert() -> Result<(), DbErr> {
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
Syntax::Postgres,
DatabaseBackend::Postgres,
r#"INSERT INTO "cake" ("name") VALUES ($1)"#,
vec!["Apple Pie".into()]
)]
@ -43,7 +43,7 @@ async fn test_select() -> Result<(), DbErr> {
filling_id: 3,
}];
let db = MockDatabase::new(Syntax::Postgres)
let db = MockDatabase::new(DatabaseBackend::Postgres)
.append_query_results(vec![query_results.clone()])
.into_connection();
@ -54,7 +54,7 @@ async fn test_select() -> Result<(), DbErr> {
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
Syntax::Postgres,
DatabaseBackend::Postgres,
[
r#"SELECT "cake_filling"."cake_id", "cake_filling"."filling_id" FROM "cake_filling""#,
r#"WHERE "cake_filling"."cake_id" = $1 AND "cake_filling"."filling_id" = $2"#,
@ -73,7 +73,7 @@ async fn test_update() -> Result<(), DbErr> {
rows_affected: 1,
};
let db = MockDatabase::new(Syntax::Postgres)
let db = MockDatabase::new(DatabaseBackend::Postgres)
.append_exec_results(vec![exec_result.clone()])
.into_connection();
@ -90,7 +90,7 @@ async fn test_update() -> Result<(), DbErr> {
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
Syntax::Postgres,
DatabaseBackend::Postgres,
r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2"#,
vec!["Orange".into(), 1i32.into()]
)]
@ -106,7 +106,7 @@ async fn test_delete() -> Result<(), DbErr> {
rows_affected: 1,
};
let db = MockDatabase::new(Syntax::Postgres)
let db = MockDatabase::new(DatabaseBackend::Postgres)
.append_exec_results(vec![exec_result.clone()])
.into_connection();
@ -122,7 +122,7 @@ async fn test_delete() -> Result<(), DbErr> {
assert_eq!(
db.into_transaction_log(),
vec![Transaction::from_sql_and_values(
Syntax::Postgres,
DatabaseBackend::Postgres,
r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#,
vec![3i32.into()]
)]

81
src/database/connection.rs
View File

@ -1,8 +1,5 @@
use crate::{error::*, ExecResult, QueryResult, Statement, Syntax};
use sea_query::{
MysqlQueryBuilder, PostgresQueryBuilder, QueryStatementBuilder, SchemaStatementBuilder,
SqliteQueryBuilder,
};
use crate::{error::*, ExecResult, IntoStatement, QueryResult, Statement};
use sea_query::{MysqlQueryBuilder, PostgresQueryBuilder, QueryBuilder, SqliteQueryBuilder};
pub enum DatabaseConnection {
#[cfg(feature = "sqlx-mysql")]
@ -16,13 +13,8 @@ pub enum DatabaseConnection {
pub type DbConn = DatabaseConnection;
pub enum QueryBuilderBackend {
MySql,
Postgres,
Sqlite,
}
pub enum SchemaBuilderBackend {
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum DatabaseBackend {
MySql,
Postgres,
Sqlite,
@ -53,26 +45,14 @@ impl std::fmt::Debug for DatabaseConnection {
}
impl DatabaseConnection {
pub fn get_query_builder_backend(&self) -> QueryBuilderBackend {
pub fn get_database_backend(&self) -> DatabaseBackend {
match self {
#[cfg(feature = "sqlx-mysql")]
DatabaseConnection::SqlxMySqlPoolConnection(_) => QueryBuilderBackend::MySql,
DatabaseConnection::SqlxMySqlPoolConnection(_) => DatabaseBackend::MySql,
#[cfg(feature = "sqlx-sqlite")]
DatabaseConnection::SqlxSqlitePoolConnection(_) => QueryBuilderBackend::Sqlite,
DatabaseConnection::SqlxSqlitePoolConnection(_) => DatabaseBackend::Sqlite,
#[cfg(feature = "mock")]
DatabaseConnection::MockDatabaseConnection(conn) => conn.get_query_builder_backend(),
DatabaseConnection::Disconnected => panic!("Disconnected"),
}
}
pub fn get_schema_builder_backend(&self) -> SchemaBuilderBackend {
match self {
#[cfg(feature = "sqlx-mysql")]
DatabaseConnection::SqlxMySqlPoolConnection(_) => SchemaBuilderBackend::MySql,
#[cfg(feature = "sqlx-sqlite")]
DatabaseConnection::SqlxSqlitePoolConnection(_) => SchemaBuilderBackend::Sqlite,
#[cfg(feature = "mock")]
DatabaseConnection::MockDatabaseConnection(conn) => conn.get_schema_builder_backend(),
DatabaseConnection::MockDatabaseConnection(conn) => conn.get_database_backend(),
DatabaseConnection::Disconnected => panic!("Disconnected"),
}
}
@ -133,50 +113,19 @@ impl DatabaseConnection {
}
}
impl QueryBuilderBackend {
pub fn syntax(&self) -> Syntax {
match self {
Self::MySql => Syntax::MySql,
Self::Postgres => Syntax::Postgres,
Self::Sqlite => Syntax::Sqlite,
}
}
impl DatabaseBackend {
pub fn build<S>(&self, statement: &S) -> Statement
where
S: QueryStatementBuilder,
S: IntoStatement,
{
Statement::from_string_values_tuple(
self.syntax(),
match self {
Self::MySql => statement.build(MysqlQueryBuilder),
Self::Postgres => statement.build(PostgresQueryBuilder),
Self::Sqlite => statement.build(SqliteQueryBuilder),
},
)
statement.into_statement(self)
}
}
impl SchemaBuilderBackend {
pub fn syntax(&self) -> Syntax {
pub fn get_query_builder(&self) -> Box<dyn QueryBuilder> {
match self {
Self::MySql => Syntax::MySql,
Self::Postgres => Syntax::Postgres,
Self::Sqlite => Syntax::Sqlite,
Self::MySql => Box::new(MysqlQueryBuilder),
Self::Postgres => Box::new(PostgresQueryBuilder),
Self::Sqlite => Box::new(SqliteQueryBuilder),
}
}
pub fn build<S>(&self, statement: &S) -> Statement
where
S: SchemaStatementBuilder,
{
Statement::from_string(
self.syntax(),
match self {
Self::MySql => statement.build(MysqlQueryBuilder),
Self::Postgres => statement.build(PostgresQueryBuilder),
Self::Sqlite => statement.build(SqliteQueryBuilder),
},
)
}
}

16
src/database/mock.rs
View File

@ -1,14 +1,14 @@
use crate::{
error::*, DatabaseConnection, EntityTrait, ExecResult, ExecResultHolder, Iden, Iterable,
MockDatabaseConnection, MockDatabaseTrait, ModelTrait, QueryResult, QueryResultRow, Statement,
Syntax, Transaction,
error::*, DatabaseBackend, DatabaseConnection, EntityTrait, ExecResult, ExecResultHolder, Iden,
Iterable, MockDatabaseConnection, MockDatabaseTrait, ModelTrait, QueryResult, QueryResultRow,
Statement, Transaction,
};
use sea_query::{Value, ValueType};
use std::collections::BTreeMap;
#[derive(Debug)]
pub struct MockDatabase {
syntax: Syntax,
db_backend: DatabaseBackend,
transaction_log: Vec<Transaction>,
exec_results: Vec<MockExecResult>,
query_results: Vec<Vec<MockRow>>,
@ -43,9 +43,9 @@ where
}
impl MockDatabase {
pub fn new(syntax: Syntax) -> Self {
pub fn new(db_backend: DatabaseBackend) -> Self {
Self {
syntax,
db_backend,
transaction_log: Vec::new(),
exec_results: Vec::new(),
query_results: Vec::new(),
@ -103,8 +103,8 @@ impl MockDatabaseTrait for MockDatabase {
std::mem::take(&mut self.transaction_log)
}
fn get_syntax(&self) -> Syntax {
self.syntax
fn get_database_backend(&self) -> DatabaseBackend {
self.db_backend
}
}

102
src/database/statement.rs
View File

@ -1,38 +1,37 @@
use crate::{QueryBuilderBackend, QueryBuilderWithSyntax, SchemaBuilderBackend};
use crate::DatabaseBackend;
use sea_query::{
inject_parameters, MysqlQueryBuilder, PostgresQueryBuilder, QueryBuilder, SqliteQueryBuilder,
Values,
inject_parameters, MysqlQueryBuilder, PostgresQueryBuilder, SqliteQueryBuilder, Values,
};
use std::fmt;
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum Syntax {
MySql,
Postgres,
Sqlite,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Statement {
pub sql: String,
pub values: Option<Values>,
pub syntax: Syntax,
pub db_backend: DatabaseBackend,
}
pub trait IntoStatement {
fn into_statement(&self, db_backend: &DatabaseBackend) -> Statement;
}
impl Statement {
pub fn from_string(syntax: Syntax, stmt: String) -> Statement {
pub fn from_string(db_backend: DatabaseBackend, stmt: String) -> Statement {
Statement {
sql: stmt,
values: None,
syntax,
db_backend,
}
}
pub fn from_string_values_tuple(syntax: Syntax, stmt: (String, Values)) -> Statement {
pub fn from_string_values_tuple(
db_backend: DatabaseBackend,
stmt: (String, Values),
) -> Statement {
Statement {
sql: stmt.0,
values: Some(stmt.1),
syntax,
db_backend,
}
}
}
@ -44,7 +43,7 @@ impl fmt::Display for Statement {
let string = inject_parameters(
&self.sql,
values.0.clone(),
self.syntax.get_query_builder().as_ref(),
self.db_backend.get_query_builder().as_ref(),
);
write!(f, "{}", &string)
}
@ -55,46 +54,45 @@ impl fmt::Display for Statement {
}
}
impl Syntax {
pub fn get_query_builder(&self) -> Box<dyn QueryBuilder> {
match self {
Self::MySql => Box::new(MysqlQueryBuilder),
Self::Postgres => Box::new(PostgresQueryBuilder),
Self::Sqlite => Box::new(SqliteQueryBuilder),
macro_rules! build_any_stmt {
($stmt: expr, $db_backend: expr) => {
match $db_backend {
DatabaseBackend::MySql => $stmt.build(MysqlQueryBuilder),
DatabaseBackend::Postgres => $stmt.build(PostgresQueryBuilder),
DatabaseBackend::Sqlite => $stmt.build(SqliteQueryBuilder),
}
}
};
}
pub fn get_query_builder_backend(&self) -> QueryBuilderBackend {
match self {
Self::MySql => QueryBuilderBackend::MySql,
Self::Postgres => QueryBuilderBackend::Postgres,
Self::Sqlite => QueryBuilderBackend::Sqlite,
macro_rules! build_query_stmt {
($stmt: ty) => {
impl IntoStatement for $stmt {
fn into_statement(&self, db_backend: &DatabaseBackend) -> Statement {
let stmt = build_any_stmt!(self, db_backend);
Statement::from_string_values_tuple(*db_backend, stmt)
}
}
}
};
}
pub fn get_schema_builder_backend(&self) -> SchemaBuilderBackend {
match self {
Self::MySql => SchemaBuilderBackend::MySql,
Self::Postgres => SchemaBuilderBackend::Postgres,
Self::Sqlite => SchemaBuilderBackend::Sqlite,
build_query_stmt!(sea_query::InsertStatement);
build_query_stmt!(sea_query::SelectStatement);
build_query_stmt!(sea_query::UpdateStatement);
build_query_stmt!(sea_query::DeleteStatement);
macro_rules! build_schema_stmt {
($stmt: ty) => {
impl IntoStatement for $stmt {
fn into_statement(&self, db_backend: &DatabaseBackend) -> Statement {
let stmt = build_any_stmt!(self, db_backend);
Statement::from_string(*db_backend, stmt)
}
}
}
};
}
impl QueryBuilderWithSyntax for MysqlQueryBuilder {
fn syntax(&self) -> Syntax {
Syntax::MySql
}
}
impl QueryBuilderWithSyntax for PostgresQueryBuilder {
fn syntax(&self) -> Syntax {
Syntax::Postgres
}
}
impl QueryBuilderWithSyntax for SqliteQueryBuilder {
fn syntax(&self) -> Syntax {
Syntax::Sqlite
}
}
build_schema_stmt!(sea_query::TableCreateStatement);
build_schema_stmt!(sea_query::TableDropStatement);
build_schema_stmt!(sea_query::TableAlterStatement);
build_schema_stmt!(sea_query::TableRenameStatement);
build_schema_stmt!(sea_query::TableTruncateStatement);

6
src/database/transaction.rs
View File

@ -1,4 +1,4 @@
use crate::{Statement, Syntax};
use crate::{DatabaseBackend, Statement};
use sea_query::{Value, Values};
#[derive(Debug, Clone, PartialEq)]
@ -7,12 +7,12 @@ pub struct Transaction {
}
impl Transaction {
pub fn from_sql_and_values<I>(syntax: Syntax, sql: &str, values: I) -> Self
pub fn from_sql_and_values<I>(db_backend: DatabaseBackend, sql: &str, values: I) -> Self
where
I: IntoIterator<Item = Value>,
{
Self::one(Statement::from_string_values_tuple(
syntax,
db_backend,
(sql.to_string(), Values(values.into_iter().collect())),
))
}

28
src/driver/mock.rs
View File

@ -1,6 +1,6 @@
use crate::{
debug_print, error::*, DatabaseConnection, ExecResult, MockDatabase, QueryBuilderBackend,
QueryResult, SchemaBuilderBackend, Statement, Syntax, Transaction,
debug_print, error::*, DatabaseBackend, DatabaseConnection, ExecResult, MockDatabase,
QueryResult, Statement, Transaction,
};
use std::sync::{
atomic::{AtomicUsize, Ordering},
@ -21,7 +21,7 @@ pub trait MockDatabaseTrait: Send {
fn drain_transaction_log(&mut self) -> Vec<Transaction>;
fn get_syntax(&self) -> Syntax;
fn get_database_backend(&self) -> DatabaseBackend;
}
impl MockDatabaseConnector {
@ -48,13 +48,13 @@ impl MockDatabaseConnector {
#[cfg(feature = "sqlx-mysql")]
if crate::SqlxMySqlConnector::accepts(string) {
return connect_mock_db!(Syntax::MySql);
return connect_mock_db!(DatabaseBackend::MySql);
}
#[cfg(feature = "sqlx-sqlite")]
if crate::SqlxSqliteConnector::accepts(string) {
return connect_mock_db!(Syntax::Sqlite);
return connect_mock_db!(DatabaseBackend::Sqlite);
}
connect_mock_db!(Syntax::Postgres)
connect_mock_db!(DatabaseBackend::Postgres)
}
}
@ -92,19 +92,7 @@ impl MockDatabaseConnection {
self.mocker.lock().unwrap().query(counter, statement)
}
pub fn get_query_builder_backend(&self) -> QueryBuilderBackend {
self.mocker
.lock()
.unwrap()
.get_syntax()
.get_query_builder_backend()
}
pub fn get_schema_builder_backend(&self) -> SchemaBuilderBackend {
self.mocker
.lock()
.unwrap()
.get_syntax()
.get_schema_builder_backend()
pub fn get_database_backend(&self) -> DatabaseBackend {
self.mocker.lock().unwrap().get_database_backend()
}
}

56
src/entity/base_entity.rs
View File

@ -70,9 +70,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_query_results(vec![
/// # vec![
/// # cake::Model {
@ -126,10 +126,10 @@ pub trait EntityTrait: EntityName {
/// db.into_transaction_log(),
/// vec![
/// Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#, vec![1u64.into()]
/// DatabaseBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#, vec![1u64.into()]
/// ),
/// Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake""#, vec![]
/// DatabaseBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake""#, vec![]
/// ),
/// ]);
/// ```
@ -143,9 +143,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_query_results(vec![
/// # vec![
/// # cake::Model {
@ -174,15 +174,15 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."id" = $1"#, vec![11i32.into()]
/// DatabaseBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."id" = $1"#, vec![11i32.into()]
/// )]);
/// ```
/// Find by composite key
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_query_results(vec![
/// # vec![
/// # cake_filling::Model {
@ -211,7 +211,7 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres,
/// DatabaseBackend::Postgres,
/// [
/// r#"SELECT "cake_filling"."cake_id", "cake_filling"."filling_id" FROM "cake_filling""#,
/// r#"WHERE "cake_filling"."cake_id" = $1 AND "cake_filling"."filling_id" = $2"#,
@ -245,9 +245,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_exec_results(vec![
/// # MockExecResult {
/// # last_insert_id: 15,
@ -276,7 +276,7 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1)"#, vec!["Apple Pie".into()]
/// DatabaseBackend::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1)"#, vec!["Apple Pie".into()]
/// )]);
/// ```
fn insert<A>(model: A) -> Insert<A>
@ -292,9 +292,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_exec_results(vec![
/// # MockExecResult {
/// # last_insert_id: 28,
@ -327,7 +327,7 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1), ($2)"#,
/// DatabaseBackend::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1), ($2)"#,
/// vec!["Apple Pie".into(), "Orange Scone".into()]
/// )]);
/// ```
@ -347,9 +347,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_exec_results(vec![
/// # MockExecResult {
/// # last_insert_id: 0,
@ -379,7 +379,7 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2"#, vec!["Orange".into(), 1i32.into()]
/// DatabaseBackend::Postgres, r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2"#, vec!["Orange".into(), 1i32.into()]
/// )]);
/// ```
fn update<A>(model: A) -> UpdateOne<A>
@ -397,9 +397,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_exec_results(vec![
/// # MockExecResult {
/// # last_insert_id: 0,
@ -426,7 +426,7 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"UPDATE "fruit" SET "cake_id" = $1 WHERE "fruit"."name" LIKE $2"#, vec![Value::Null, "%Apple%".into()]
/// DatabaseBackend::Postgres, r#"UPDATE "fruit" SET "cake_id" = $1 WHERE "fruit"."name" LIKE $2"#, vec![Value::Null, "%Apple%".into()]
/// )]);
/// ```
fn update_many() -> UpdateMany<Self> {
@ -441,9 +441,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_exec_results(vec![
/// # MockExecResult {
/// # last_insert_id: 0,
@ -471,7 +471,7 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#, vec![3i32.into()]
/// DatabaseBackend::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#, vec![3i32.into()]
/// )]);
/// ```
fn delete<A>(model: A) -> DeleteOne<A>
@ -489,9 +489,9 @@ pub trait EntityTrait: EntityName {
///
/// ```
/// # #[cfg(feature = "mock")]
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
/// #
/// # let db = MockDatabase::new(Syntax::Postgres)
/// # let db = MockDatabase::new(DatabaseBackend::Postgres)
/// # .append_exec_results(vec![
/// # MockExecResult {
/// # last_insert_id: 0,
@ -517,7 +517,7 @@ pub trait EntityTrait: EntityName {
/// assert_eq!(
/// db.into_transaction_log(),
/// vec![Transaction::from_sql_and_values(
/// Syntax::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE $1"#, vec!["%Apple%".into()]
/// DatabaseBackend::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE $1"#, vec!["%Apple%".into()]
/// )]);
/// ```
fn delete_many() -> DeleteMany<Self> {

28
src/entity/column.rs
View File

@ -88,12 +88,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
bind_oper!(lte);
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Id.between(2,3))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` BETWEEN 2 AND 3"
/// );
@ -106,12 +106,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
}
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Id.not_between(2,3))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` NOT BETWEEN 2 AND 3"
/// );
@ -124,12 +124,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
}
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Name.like("cheese"))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese'"
/// );
@ -139,12 +139,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
}
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Name.not_like("cheese"))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` NOT LIKE 'cheese'"
/// );
@ -154,12 +154,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
}
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Name.starts_with("cheese"))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese%'"
/// );
@ -170,12 +170,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
}
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Name.ends_with("cheese"))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese'"
/// );
@ -186,12 +186,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
}
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Name.contains("cheese"))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese%'"
/// );

2
src/executor/delete.rs
View File

@ -49,7 +49,7 @@ impl Deleter {
self,
db: &DatabaseConnection,
) -> impl Future<Output = Result<DeleteResult, DbErr>> + '_ {
let builder = db.get_query_builder_backend();
let builder = db.get_database_backend();
exec_delete(builder.build(&self.query), db)
}
}

2
src/executor/insert.rs
View File

@ -34,7 +34,7 @@ impl Inserter {
self,
db: &DatabaseConnection,
) -> impl Future<Output = Result<InsertResult, DbErr>> + '_ {
let builder = db.get_query_builder_backend();
let builder = db.get_database_backend();
exec_insert(builder.build(&self.query), db)
}
}

20
src/executor/paginator.rs
View File

@ -30,7 +30,7 @@ where
.limit(self.page_size as u64)
.offset((self.page_size * page) as u64)
.to_owned();
let builder = self.db.get_query_builder_backend();
let builder = self.db.get_database_backend();
let stmt = builder.build(&query);
let rows = self.db.query_all(stmt).await?;
let mut buffer = Vec::with_capacity(rows.len());
@ -48,7 +48,7 @@ where
/// Get the total number of pages
pub async fn num_pages(&self) -> Result<usize, DbErr> {
let builder = self.db.get_query_builder_backend();
let builder = self.db.get_database_backend();
let stmt = builder.build(
SelectStatement::new()
.expr(Expr::cust("COUNT(*) AS num_rows"))
@ -103,7 +103,7 @@ where
mod tests {
use crate::entity::prelude::*;
use crate::tests_cfg::*;
use crate::{DatabaseConnection, MockDatabase, Syntax, Transaction};
use crate::{DatabaseBackend, DatabaseConnection, MockDatabase, Transaction};
use futures::TryStreamExt;
use sea_query::{Alias, Expr, SelectStatement, Value};
@ -129,7 +129,7 @@ mod tests {
let page3 = Vec::<fruit::Model>::new();
let db = MockDatabase::new(Syntax::Postgres)
let db = MockDatabase::new(DatabaseBackend::Postgres)
.append_query_results(vec![page1.clone(), page2.clone(), page3.clone()])
.into_connection();
@ -138,7 +138,7 @@ mod tests {
fn setup_num_rows() -> (DatabaseConnection, i32) {
let num_rows = 3;
let db = MockDatabase::new(Syntax::Postgres)
let db = MockDatabase::new(DatabaseBackend::Postgres)
.append_query_results(vec![vec![maplit::btreemap! {
"num_rows" => Into::<Value>::into(num_rows),
}]])
@ -166,7 +166,7 @@ mod tests {
.from(fruit::Entity)
.to_owned();
let query_builder = db.get_query_builder_backend();
let query_builder = db.get_database_backend();
let stmts = vec![
query_builder.build(select.clone().offset(0).limit(2)),
query_builder.build(select.clone().offset(2).limit(2)),
@ -200,7 +200,7 @@ mod tests {
.from(fruit::Entity)
.to_owned();
let query_builder = db.get_query_builder_backend();
let query_builder = db.get_database_backend();
let stmts = vec![
query_builder.build(select.clone().offset(0).limit(2)),
query_builder.build(select.clone().offset(2).limit(2)),
@ -236,7 +236,7 @@ mod tests {
.from_subquery(sub_query, Alias::new("sub_query"))
.to_owned();
let query_builder = db.get_query_builder_backend();
let query_builder = db.get_database_backend();
let stmts = vec![query_builder.build(&select)];
assert_eq!(db.into_transaction_log(), Transaction::wrap(stmts));
@ -283,7 +283,7 @@ mod tests {
.from(fruit::Entity)
.to_owned();
let query_builder = db.get_query_builder_backend();
let query_builder = db.get_database_backend();
let stmts = vec![
query_builder.build(select.clone().offset(0).limit(2)),
query_builder.build(select.clone().offset(2).limit(2)),
@ -315,7 +315,7 @@ mod tests {
.from(fruit::Entity)
.to_owned();
let query_builder = db.get_query_builder_backend();
let query_builder = db.get_database_backend();
let stmts = vec![
query_builder.build(select.clone().offset(0).limit(2)),
query_builder.build(select.clone().offset(2).limit(2)),

4
src/executor/select.rs
View File

@ -186,7 +186,7 @@ where
S: SelectorTrait,
{
pub async fn one(mut self, db: &DatabaseConnection) -> Result<Option<S::Item>, DbErr> {
let builder = db.get_query_builder_backend();
let builder = db.get_database_backend();
self.query.limit(1);
let row = db.query_one(builder.build(&self.query)).await?;
match row {
@ -196,7 +196,7 @@ where
}
pub async fn all(self, db: &DatabaseConnection) -> Result<Vec<S::Item>, DbErr> {
let builder = db.get_query_builder_backend();
let builder = db.get_database_backend();
let rows = db.query_all(builder.build(&self.query)).await?;
let mut models = Vec::new();
for row in rows.into_iter() {

2
src/executor/update.rs
View File

@ -46,7 +46,7 @@ impl Updater {
self,
db: &DatabaseConnection,
) -> impl Future<Output = Result<UpdateResult, DbErr>> + '_ {
let builder = db.get_query_builder_backend();
let builder = db.get_database_backend();
exec_update(builder.build(&self.query), db)
}
}

12
src/query/combine.rs
View File

@ -113,7 +113,7 @@ where
#[cfg(test)]
mod tests {
use crate::tests_cfg::{cake, fruit};
use crate::{ColumnTrait, EntityTrait, QueryFilter, QuerySelect, QueryTrait, Syntax};
use crate::{ColumnTrait, DatabaseBackend, EntityTrait, QueryFilter, QuerySelect, QueryTrait};
#[test]
fn alias_1() {
@ -121,7 +121,7 @@ mod tests {
cake::Entity::find()
.column_as(cake::Column::Id, "B")
.apply_alias("A_")
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`, `cake`.`id` AS `A_B` FROM `cake`",
);
@ -133,7 +133,7 @@ mod tests {
cake::Entity::find()
.left_join(fruit::Entity)
.select_also(fruit::Entity)
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",
@ -149,7 +149,7 @@ mod tests {
cake::Entity::find()
.left_join(fruit::Entity)
.select_with(fruit::Entity)
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",
@ -168,7 +168,7 @@ mod tests {
.select_also(fruit::Entity)
.filter(cake::Column::Id.eq(1))
.filter(fruit::Column::Id.eq(2))
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",
@ -187,7 +187,7 @@ mod tests {
.select_with(fruit::Entity)
.filter(cake::Column::Id.eq(1))
.filter(fruit::Column::Id.eq(2))
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",

20
src/query/delete.rs
View File

@ -31,28 +31,28 @@ impl Delete {
///
/// Model
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// Delete::one(cake::Model {
/// id: 1,
/// name: "Apple Pie".to_owned(),
/// })
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
/// );
/// ```
/// ActiveModel
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// Delete::one(cake::ActiveModel {
/// id: ActiveValue::set(1),
/// name: ActiveValue::set("Apple Pie".to_owned()),
/// })
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
/// );
@ -75,12 +75,12 @@ impl Delete {
/// Delete many ActiveModel
///
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::fruit, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::fruit, DatabaseBackend};
///
/// assert_eq!(
/// Delete::many(fruit::Entity)
/// .filter(fruit::Column::Name.contains("Apple"))
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE '%Apple%'"#,
/// );
@ -179,7 +179,7 @@ where
#[cfg(test)]
mod tests {
use crate::tests_cfg::{cake, fruit};
use crate::{entity::*, query::*, Syntax};
use crate::{entity::*, query::*, DatabaseBackend};
#[test]
fn delete_1() {
@ -188,7 +188,7 @@ mod tests {
id: 1,
name: "Apple Pie".to_owned(),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
);
@ -197,7 +197,7 @@ mod tests {
id: ActiveValue::set(1),
name: ActiveValue::set("Apple Pie".to_owned()),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
);
@ -208,7 +208,7 @@ mod tests {
assert_eq!(
Delete::many(fruit::Entity)
.filter(fruit::Column::Name.contains("Cheese"))
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE '%Cheese%'"#,
);

36
src/query/helper.rs
View File

@ -23,13 +23,13 @@ pub trait QuerySelect: Sized {
/// Add a select column
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .select_only()
/// .column(cake::Column::Name)
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"SELECT "cake"."name" FROM "cake""#
/// );
@ -44,13 +44,13 @@ pub trait QuerySelect: Sized {
/// Add a select column with alias
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .select_only()
/// .column_as(cake::Column::Id.count(), "count")
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"SELECT COUNT("cake"."id") AS "count" FROM "cake""#
/// );
@ -68,14 +68,14 @@ pub trait QuerySelect: Sized {
/// Add a group by column
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .select_only()
/// .column(cake::Column::Name)
/// .group_by(cake::Column::Name)
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"SELECT "cake"."name" FROM "cake" GROUP BY "cake"."name""#
/// );
@ -90,13 +90,13 @@ pub trait QuerySelect: Sized {
/// Add an AND HAVING expression
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .having(cake::Column::Id.eq(4))
/// .having(cake::Column::Id.eq(5))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` HAVING `cake`.`id` = 4 AND `cake`.`id` = 5"
/// );
@ -151,13 +151,13 @@ pub trait QueryOrder: Sized {
/// Add an order_by expression
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .order_by(cake::Column::Id, Order::Asc)
/// .order_by(cake::Column::Name, Order::Desc)
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` ASC, `cake`.`name` DESC"
/// );
@ -172,12 +172,12 @@ pub trait QueryOrder: Sized {
/// Add an order_by expression (ascending)
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .order_by_asc(cake::Column::Id)
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` ASC"
/// );
@ -193,12 +193,12 @@ pub trait QueryOrder: Sized {
/// Add an order_by expression (descending)
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .order_by_desc(cake::Column::Id)
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` DESC"
/// );
@ -221,13 +221,13 @@ pub trait QueryFilter: Sized {
/// Add an AND WHERE expression
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
/// .filter(cake::Column::Id.eq(4))
/// .filter(cake::Column::Id.eq(5))
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` = 4 AND `cake`.`id` = 5"
/// );
@ -235,7 +235,7 @@ pub trait QueryFilter: Sized {
///
/// Add a condition tree.
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// cake::Entity::find()
@ -244,7 +244,7 @@ pub trait QueryFilter: Sized {
/// .add(cake::Column::Id.eq(4))
/// .add(cake::Column::Id.eq(5))
/// )
/// .build(Syntax::MySql)
/// .build(DatabaseBackend::MySql)
/// .to_string(),
/// "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` = 4 OR `cake`.`id` = 5"
/// );

24
src/query/insert.rs
View File

@ -39,28 +39,28 @@ where
///
/// Model
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// Insert::one(cake::Model {
/// id: 1,
/// name: "Apple Pie".to_owned(),
/// })
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#,
/// );
/// ```
/// ActiveModel
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// Insert::one(cake::ActiveModel {
/// id: Unset(None),
/// name: Set("Apple Pie".to_owned()),
/// })
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"INSERT INTO "cake" ("name") VALUES ('Apple Pie')"#,
/// );
@ -75,7 +75,7 @@ where
/// Insert many Model or ActiveModel
///
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// Insert::many(vec![
@ -88,7 +88,7 @@ where
/// name: "Orange Scone".to_owned(),
/// }
/// ])
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie'), (2, 'Orange Scone')"#,
/// );
@ -162,7 +162,7 @@ where
#[cfg(test)]
mod tests {
use crate::tests_cfg::cake;
use crate::{ActiveValue, Insert, QueryTrait, Syntax};
use crate::{ActiveValue, DatabaseBackend, Insert, QueryTrait};
#[test]
fn insert_1() {
@ -172,7 +172,7 @@ mod tests {
id: ActiveValue::unset(),
name: ActiveValue::set("Apple Pie".to_owned()),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"INSERT INTO "cake" ("name") VALUES ('Apple Pie')"#,
);
@ -186,7 +186,7 @@ mod tests {
id: ActiveValue::set(1),
name: ActiveValue::set("Apple Pie".to_owned()),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#,
);
@ -200,7 +200,7 @@ mod tests {
id: 1,
name: "Apple Pie".to_owned(),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#,
);
@ -220,7 +220,7 @@ mod tests {
name: "Orange Scone".to_owned(),
}
])
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie'), (2, 'Orange Scone')"#,
);
@ -240,7 +240,7 @@ mod tests {
assert_eq!(
Insert::<cake::ActiveModel>::new()
.add_many(vec![apple, orange])
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"INSERT INTO "cake" ("id", "name") VALUES (NULL, 'Apple'), (2, 'Orange')"#,
);

16
src/query/join.rs
View File

@ -62,14 +62,14 @@ where
#[cfg(test)]
mod tests {
use crate::tests_cfg::{cake, filling, fruit};
use crate::{ColumnTrait, EntityTrait, ModelTrait, QueryFilter, QueryTrait, Syntax};
use crate::{ColumnTrait, DatabaseBackend, EntityTrait, ModelTrait, QueryFilter, QueryTrait};
#[test]
fn join_1() {
assert_eq!(
cake::Entity::find()
.left_join(fruit::Entity)
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
@ -85,7 +85,7 @@ mod tests {
cake::Entity::find()
.inner_join(fruit::Entity)
.filter(fruit::Column::Name.contains("cherry"))
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
@ -101,7 +101,7 @@ mod tests {
assert_eq!(
fruit::Entity::find()
.reverse_join(cake::Entity)
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
@ -119,7 +119,7 @@ mod tests {
assert_eq!(
find_fruit
.filter(cake::Column::Id.eq(11))
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
@ -140,7 +140,7 @@ mod tests {
assert_eq!(
cake_model
.find_related(fruit::Entity)
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
@ -156,7 +156,7 @@ mod tests {
assert_eq!(
cake::Entity::find()
.left_join(filling::Entity)
.build(Syntax::MySql)
.build(DatabaseBackend::MySql)
.to_string(),
[
"SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
@ -173,7 +173,7 @@ mod tests {
let find_filling: Select<filling::Entity> = cake::Entity::find_related();
assert_eq!(
find_filling.build(Syntax::MySql).to_string(),
find_filling.build(DatabaseBackend::MySql).to_string(),
[
"SELECT `filling`.`id`, `filling`.`name` FROM `filling`",
"INNER JOIN `cake_filling` ON `cake_filling`.`filling_id` = `filling`.`id`",

4
src/query/json.rs
View File

@ -102,12 +102,12 @@ impl FromQueryResult for JsonValue {
#[cfg(feature = "mock")]
mod tests {
use crate::tests_cfg::cake;
use crate::{entity::*, MockDatabase, Syntax};
use crate::{entity::*, DatabaseBackend, MockDatabase};
use sea_query::Value;
#[async_std::test]
async fn to_json_1() {
let db = MockDatabase::new(Syntax::Postgres)
let db = MockDatabase::new(DatabaseBackend::Postgres)
.append_query_results(vec![vec![maplit::btreemap! {
"id" => Into::<Value>::into(128), "name" => Into::<Value>::into("apple")
}]])

14
src/query/traits.rs
View File

@ -1,5 +1,5 @@
use crate::{Statement, Syntax};
use sea_query::{QueryBuilder, QueryStatementBuilder};
use crate::{DatabaseBackend, Statement};
use sea_query::QueryStatementBuilder;
pub trait QueryTrait {
type QueryStatement: QueryStatementBuilder;
@ -14,15 +14,11 @@ pub trait QueryTrait {
fn into_query(self) -> Self::QueryStatement;
/// Build the query as [`Statement`]
fn build(&self, syntax: Syntax) -> Statement {
let query_builder = syntax.get_query_builder();
fn build(&self, db_backend: DatabaseBackend) -> Statement {
let query_builder = db_backend.get_query_builder();
Statement::from_string_values_tuple(
syntax,
db_backend,
self.as_query().build_any(query_builder.as_ref()),
)
}
}
pub trait QueryBuilderWithSyntax: QueryBuilder {
fn syntax(&self) -> Syntax;
}

18
src/query/update.rs
View File

@ -30,14 +30,14 @@ impl Update {
/// Update one ActiveModel
///
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
///
/// assert_eq!(
/// Update::one(cake::ActiveModel {
/// id: ActiveValue::set(1),
/// name: ActiveValue::set("Apple Pie".to_owned()),
/// })
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"UPDATE "cake" SET "name" = 'Apple Pie' WHERE "cake"."id" = 1"#,
/// );
@ -59,13 +59,13 @@ impl Update {
/// Update many ActiveModel
///
/// ```
/// use sea_orm::{entity::*, query::*, tests_cfg::fruit, sea_query::Expr, Syntax};
/// use sea_orm::{entity::*, query::*, tests_cfg::fruit, sea_query::Expr, DatabaseBackend};
///
/// assert_eq!(
/// Update::many(fruit::Entity)
/// .col_expr(fruit::Column::Name, Expr::value("Golden Apple"))
/// .filter(fruit::Column::Name.contains("Apple"))
/// .build(Syntax::Postgres)
/// .build(DatabaseBackend::Postgres)
/// .to_string(),
/// r#"UPDATE "fruit" SET "name" = 'Golden Apple' WHERE "fruit"."name" LIKE '%Apple%'"#,
/// );
@ -184,7 +184,7 @@ where
#[cfg(test)]
mod tests {
use crate::tests_cfg::{cake, fruit};
use crate::{entity::*, query::*, Syntax};
use crate::{entity::*, query::*, DatabaseBackend};
use sea_query::{Expr, Value};
#[test]
@ -194,7 +194,7 @@ mod tests {
id: ActiveValue::set(1),
name: ActiveValue::set("Apple Pie".to_owned()),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"UPDATE "cake" SET "name" = 'Apple Pie' WHERE "cake"."id" = 1"#,
);
@ -208,7 +208,7 @@ mod tests {
name: ActiveValue::set("Orange".to_owned()),
cake_id: ActiveValue::unset(),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"UPDATE "fruit" SET "name" = 'Orange' WHERE "fruit"."id" = 1"#,
);
@ -222,7 +222,7 @@ mod tests {
name: ActiveValue::unchanged("Apple".to_owned()),
cake_id: ActiveValue::set(Some(3)),
})
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"UPDATE "fruit" SET "cake_id" = 3 WHERE "fruit"."id" = 2"#,
);
@ -234,7 +234,7 @@ mod tests {
Update::many(fruit::Entity)
.col_expr(fruit::Column::CakeId, Expr::value(Value::Null))
.filter(fruit::Column::Id.eq(2))
.build(Syntax::Postgres)
.build(DatabaseBackend::Postgres)
.to_string(),
r#"UPDATE "fruit" SET "cake_id" = NULL WHERE "fruit"."id" = 2"#,
);

4
tests/basic.rs
View File

@ -1,4 +1,4 @@
use sea_orm::{entity::*, error::*, sea_query, tests_cfg::*, DbConn, Statement, Syntax};
use sea_orm::{entity::*, error::*, sea_query, tests_cfg::*, DatabaseBackend, DbConn, Statement};
mod setup;
@ -28,7 +28,7 @@ async fn setup_schema(db: &DbConn) {
.build(SqliteQueryBuilder);
let result = db
.execute(Statement::from_string(Syntax::Sqlite, stmt))
.execute(Statement::from_string(DatabaseBackend::Sqlite, stmt))
.await;
println!("Create table cake: {:?}", result);
}

2
tests/schema/mod.rs
View File

@ -4,7 +4,7 @@ use sea_query::{ColumnDef, ForeignKey, ForeignKeyAction, Index, TableCreateState
pub use super::bakery_chain::*;
async fn create_table(db: &DbConn, stmt: &TableCreateStatement) -> Result<ExecResult, DbErr> {
let builder = db.get_schema_builder_backend();
let builder = db.get_database_backend();
db.execute(builder.build(stmt)).await
}