Impl Into<QueryStatement> for SelectStatement, etc (#905)

* Remove `into_sub_query_statement` from trait

* Add back into_sub_query_statement

Author: tyt2y3

src/expr.rs

@@ -459,10 +459,7 @@ pub trait ExprTrait: Sized {
     /// );
     /// ```
     fn in_subquery(self, sel: SelectStatement) -> Expr {
-        self.binary(
-            BinOper::In,
-            Expr::SubQuery(None, Box::new(sel.into_sub_query_statement())),
-        )
+        self.binary(BinOper::In, Expr::SubQuery(None, Box::new(sel.into())))
     }
 
     /// Express a `IN` sub expression.
@@ -1170,10 +1167,7 @@ pub trait ExprTrait: Sized {
     /// );
     /// ```
     fn not_in_subquery(self, sel: SelectStatement) -> Expr {
-        self.binary(
-            BinOper::NotIn,
-            Expr::SubQuery(None, Box::new(sel.into_sub_query_statement())),
-        )
+        self.binary(BinOper::NotIn, Expr::SubQuery(None, Box::new(sel.into())))
     }
 
     /// Express a `NOT LIKE` expression.
@@ -2121,10 +2115,7 @@ impl Expr {
     /// );
     /// ```
     pub fn exists(sel: SelectStatement) -> Self {
-        Self::SubQuery(
-            Some(SubQueryOper::Exists),
-            Box::new(sel.into_sub_query_statement()),
-        )
+        Self::SubQuery(Some(SubQueryOper::Exists), Box::new(sel.into()))
     }
 
     /// Express a `ANY` sub-query expression.
@@ -2152,10 +2143,7 @@ impl Expr {
     /// );
     /// ```
     pub fn any(sel: SelectStatement) -> Self {
-        Self::SubQuery(
-            Some(SubQueryOper::Any),
-            Box::new(sel.into_sub_query_statement()),
-        )
+        Self::SubQuery(Some(SubQueryOper::Any), Box::new(sel.into()))
     }
 
     /// Express a `SOME` sub-query expression.
@@ -2183,18 +2171,12 @@ impl Expr {
     /// );
     /// ```
     pub fn some(sel: SelectStatement) -> Self {
-        Self::SubQuery(
-            Some(SubQueryOper::Some),
-            Box::new(sel.into_sub_query_statement()),
-        )
+        Self::SubQuery(Some(SubQueryOper::Some), Box::new(sel.into()))
     }
 
     /// Express a `ALL` sub-query expression.
     pub fn all(sel: SelectStatement) -> Self {
-        Self::SubQuery(
-            Some(SubQueryOper::All),
-            Box::new(sel.into_sub_query_statement()),
-        )
+        Self::SubQuery(Some(SubQueryOper::All), Box::new(sel.into()))
     }
 
     /// Adds new `CASE WHEN` to existing case statement.

src/query/delete.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Expr, QueryStatementBuilder, QueryStatementWriter, ReturningClause, SubQueryStatement,
-    WithClause, WithQuery,
+    Expr, QueryStatement, QueryStatementBuilder, QueryStatementWriter, ReturningClause,
+    SubQueryStatement, WithClause, WithQuery,
     backend::QueryBuilder,
     prepare::*,
     query::{OrderedStatement, condition::*},
@@ -281,10 +281,6 @@ impl QueryStatementBuilder for DeleteStatement {
         query_builder.prepare_delete_statement(self, sql);
     }
 
-    pub fn into_sub_query_statement(self) -> SubQueryStatement {
-        SubQueryStatement::DeleteStatement(self)
-    }
-
     pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values);
     pub fn build_collect_any(
         &self,
@@ -293,6 +289,18 @@ impl QueryStatementBuilder for DeleteStatement {
     ) -> String;
 }
 
+impl From<DeleteStatement> for QueryStatement {
+    fn from(s: DeleteStatement) -> Self {
+        Self::Delete(s)
+    }
+}
+
+impl From<DeleteStatement> for SubQueryStatement {
+    fn from(s: DeleteStatement) -> Self {
+        Self::DeleteStatement(s)
+    }
+}
+
 #[inherent]
 impl QueryStatementWriter for DeleteStatement {
     pub fn build_collect_into<T: QueryBuilder>(&self, query_builder: T, sql: &mut dyn SqlWriter) {

src/query/insert.rs

@@ -1,5 +1,5 @@
 use crate::{
-    Expr, OnConflict, QueryStatementBuilder, QueryStatementWriter, ReturningClause,
+    Expr, OnConflict, QueryStatement, QueryStatementBuilder, QueryStatementWriter, ReturningClause,
     SelectStatement, SubQueryStatement, Values, WithClause, WithQuery, backend::QueryBuilder,
     error::*, prepare::*, types::*,
 };
@@ -638,10 +638,6 @@ impl QueryStatementBuilder for InsertStatement {
         query_builder.prepare_insert_statement(self, sql);
     }
 
-    pub fn into_sub_query_statement(self) -> SubQueryStatement {
-        SubQueryStatement::InsertStatement(self)
-    }
-
     pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values);
     pub fn build_collect_any(
         &self,
@@ -650,6 +646,18 @@ impl QueryStatementBuilder for InsertStatement {
     ) -> String;
 }
 
+impl From<InsertStatement> for QueryStatement {
+    fn from(s: InsertStatement) -> Self {
+        Self::Insert(s)
+    }
+}
+
+impl From<InsertStatement> for SubQueryStatement {
+    fn from(s: InsertStatement) -> Self {
+        Self::InsertStatement(s)
+    }
+}
+
 #[inherent]
 impl QueryStatementWriter for InsertStatement {
     pub fn build_collect_into<T: QueryBuilder>(&self, query_builder: T, sql: &mut dyn SqlWriter) {

src/query/select.rs

@@ -1,6 +1,6 @@
 use crate::{
-    FunctionCall, QueryStatementBuilder, QueryStatementWriter, SubQueryStatement, WindowStatement,
-    WithClause, WithQuery,
+    FunctionCall, QueryStatement, QueryStatementBuilder, QueryStatementWriter, SubQueryStatement,
+    WindowStatement, WithClause, WithQuery,
     backend::QueryBuilder,
     expr::*,
     prepare::*,
@@ -2465,10 +2465,6 @@ impl QueryStatementBuilder for SelectStatement {
         query_builder.prepare_select_statement(self, sql);
     }
 
-    pub fn into_sub_query_statement(self) -> SubQueryStatement {
-        SubQueryStatement::SelectStatement(self)
-    }
-
     pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values);
     pub fn build_collect_any(
         &self,
@@ -2477,6 +2473,18 @@ impl QueryStatementBuilder for SelectStatement {
     ) -> String;
 }
 
+impl From<SelectStatement> for QueryStatement {
+    fn from(s: SelectStatement) -> Self {
+        Self::Select(s)
+    }
+}
+
+impl From<SelectStatement> for SubQueryStatement {
+    fn from(s: SelectStatement) -> Self {
+        Self::SelectStatement(s)
+    }
+}
+
 #[inherent]
 impl QueryStatementWriter for SelectStatement {
     pub fn build_collect_into<T: QueryBuilder>(&self, query_builder: T, sql: &mut dyn SqlWriter) {

src/query/traits.rs

@@ -2,7 +2,7 @@ use std::fmt::Debug;
 
 use crate::{SqlWriter, SqlWriterValues, SubQueryStatement, backend::QueryBuilder, value::Values};
 
-pub trait QueryStatementBuilder: Debug {
+pub trait QueryStatementBuilder: Debug + Into<SubQueryStatement> {
     /// Build corresponding SQL statement for certain database backend and collect query parameters into a vector
     fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values) {
         let (placeholder, numbered) = query_builder.placeholder();
@@ -24,7 +24,9 @@ pub trait QueryStatementBuilder: Debug {
     /// Build corresponding SQL statement into the SqlWriter for certain database backend and collect query parameters
     fn build_collect_any_into(&self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter);
 
-    fn into_sub_query_statement(self) -> SubQueryStatement;
+    fn into_sub_query_statement(self) -> SubQueryStatement {
+        self.into()
+    }
 }
 
 pub trait QueryStatementWriter: QueryStatementBuilder {

src/query/update.rs

@@ -1,8 +1,8 @@
 use inherent::inherent;
 
 use crate::{
-    QueryStatementBuilder, QueryStatementWriter, ReturningClause, SubQueryStatement, WithClause,
-    WithQuery,
+    QueryStatement, QueryStatementBuilder, QueryStatementWriter, ReturningClause,
+    SubQueryStatement, WithClause, WithQuery,
     backend::QueryBuilder,
     expr::*,
     prepare::*,
@@ -417,10 +417,6 @@ impl QueryStatementBuilder for UpdateStatement {
         query_builder.prepare_update_statement(self, sql);
     }
 
-    pub fn into_sub_query_statement(self) -> SubQueryStatement {
-        SubQueryStatement::UpdateStatement(self)
-    }
-
     pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values);
     pub fn build_collect_any(
         &self,
@@ -429,6 +425,18 @@ impl QueryStatementBuilder for UpdateStatement {
     ) -> String;
 }
 
+impl From<UpdateStatement> for QueryStatement {
+    fn from(s: UpdateStatement) -> Self {
+        Self::Update(s)
+    }
+}
+
+impl From<UpdateStatement> for SubQueryStatement {
+    fn from(s: UpdateStatement) -> Self {
+        Self::UpdateStatement(s)
+    }
+}
+
 #[inherent]
 impl QueryStatementWriter for UpdateStatement {
     pub fn build_collect_into<T: QueryBuilder>(&self, query_builder: T, sql: &mut dyn SqlWriter) {

src/query/with.rs

@@ -101,9 +101,9 @@ impl CommonTableExpression {
     /// columns.
     pub fn query<Q>(&mut self, query: Q) -> &mut Self
     where
-        Q: QueryStatementBuilder,
+        Q: Into<SubQueryStatement>,
     {
-        self.query = Some(Box::new(query.into_sub_query_statement()));
+        self.query = Some(Box::new(query.into()));
         self
     }
 
@@ -126,7 +126,7 @@ impl CommonTableExpression {
                 _ => {}
             }
         }
-        cte.query = Some(Box::new(select.into_sub_query_statement()));
+        cte.query = Some(Box::new(select.into()));
         cte
     }
 
@@ -480,7 +480,7 @@ impl WithClause {
     /// execute the argument query with this WITH clause.
     pub fn query<T>(self, query: T) -> WithQuery
     where
-        T: QueryStatementBuilder + 'static,
+        T: Into<SubQueryStatement> + 'static,
     {
         WithQuery::new().with_clause(self).query(query).to_owned()
     }
@@ -578,9 +578,9 @@ impl WithQuery {
     /// Set the query that you execute with the [WithClause].
     pub fn query<T>(&mut self, query: T) -> &mut Self
     where
-        T: QueryStatementBuilder,
+        T: Into<SubQueryStatement>,
     {
-        self.query = Some(Box::new(query.into_sub_query_statement()));
+        self.query = Some(Box::new(query.into()));
         self
     }
 }
@@ -589,9 +589,11 @@ impl QueryStatementBuilder for WithQuery {
     fn build_collect_any_into(&self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter) {
         query_builder.prepare_with_query(self, sql);
     }
+}
 
-    fn into_sub_query_statement(self) -> SubQueryStatement {
-        SubQueryStatement::WithStatement(self)
+impl From<WithQuery> for SubQueryStatement {
+    fn from(s: WithQuery) -> Self {
+        Self::WithStatement(s)
     }
 }
 

tests/mysql/query.rs

@@ -1546,10 +1546,7 @@ fn sub_query_with_fn() {
         .to_owned();
 
     let select = Query::select()
-        .expr(Func::cust(ArrayFunc).arg(Expr::SubQuery(
-            None,
-            Box::new(sub_select.into_sub_query_statement()),
-        )))
+        .expr(Func::cust(ArrayFunc).arg(Expr::SubQuery(None, Box::new(sub_select.into()))))
         .to_owned();
 
     assert_eq!(

tests/postgres/query.rs

@@ -1989,10 +1989,7 @@ fn sub_query_with_fn() {
         .to_owned();
 
     let select = Query::select()
-        .expr(Func::cust(ArrayFunc).arg(Expr::SubQuery(
-            None,
-            Box::new(sub_select.into_sub_query_statement()),
-        )))
+        .expr(Func::cust(ArrayFunc).arg(Expr::SubQuery(None, Box::new(sub_select.into()))))
         .to_owned();
 
     assert_eq!(

tests/sqlite/query.rs

@@ -1782,10 +1782,7 @@ fn sub_query_with_fn() {
         .to_owned();
 
     let select = Query::select()
-        .expr(Func::cust(ArrayFunc).arg(Expr::SubQuery(
-            None,
-            Box::new(sub_select.into_sub_query_statement()),
-        )))
+        .expr(Func::cust(ArrayFunc).arg(Expr::SubQuery(None, Box::new(sub_select.into()))))
         .to_owned();
 
     assert_eq!(