issues-179 Add support for view

src/backend/mod.rs

@@ -24,16 +24,18 @@ mod index_builder;
 mod query_builder;
 mod table_builder;
 mod table_ref_builder;
+mod view_builder;
 
 pub use self::foreign_key_builder::*;
 pub use self::index_builder::*;
 pub use self::query_builder::*;
 pub use self::table_builder::*;
 pub use self::table_ref_builder::*;
+pub use self::view_builder::*;
 
 pub trait GenericBuilder: QueryBuilder + SchemaBuilder {}
 
-pub trait SchemaBuilder: TableBuilder + IndexBuilder + ForeignKeyBuilder {}
+pub trait SchemaBuilder: TableBuilder + IndexBuilder + ForeignKeyBuilder + ViewBuilder {}
 
 pub trait QuotedBuilder {
     /// The type of quote the builder uses.

src/backend/mysql/mod.rs

@@ -2,6 +2,7 @@ pub(crate) mod foreign_key;
 pub(crate) mod index;
 pub(crate) mod query;
 pub(crate) mod table;
+pub(crate) mod view;
 
 use super::*;
 

src/backend/mysql/view.rs

@@ -0,0 +1,14 @@
+use crate::*;
+
+impl ViewBuilder for MysqlQueryBuilder {
+    fn prepare_view_rename_statement(&self, rename: &ViewRenameStatement, sql: &mut dyn SqlWriter) {
+        write!(sql, "RENAME TABLE ").unwrap();
+        if let Some(from_name) = &rename.from_name {
+            from_name.prepare(sql.as_writer(), self.quote());
+        }
+        write!(sql, " TO ").unwrap();
+        if let Some(to_name) = &rename.to_name {
+            to_name.prepare(sql.as_writer(), self.quote());
+        }
+    }
+}

src/backend/postgres/mod.rs

@@ -3,6 +3,7 @@ pub(crate) mod index;
 pub(crate) mod query;
 pub(crate) mod table;
 pub(crate) mod types;
+pub(crate) mod view;
 
 use super::*;
 

src/backend/postgres/view.rs

@@ -0,0 +1,32 @@
+use crate::*;
+
+impl ViewBuilder for PostgresQueryBuilder {
+    fn prepare_view_create_befor_view(
+        &self,
+        create: &ViewCreateStatement,
+        sql: &mut dyn SqlWriter,
+    ) {
+        if create.or_replace {
+            write!(sql, " OR REPLACE").unwrap();
+        }
+
+        if create.temporary {
+            write!(sql, " TEMPORARY").unwrap();
+        }
+
+        if create.recursive {
+            write!(sql, " RECURSIVE").unwrap();
+        }
+    }
+
+    fn prepare_view_rename_statement(&self, rename: &ViewRenameStatement, sql: &mut dyn SqlWriter) {
+        write!(sql, "ALTER VIEW ").unwrap();
+        if let Some(from_name) = &rename.from_name {
+            from_name.prepare(sql.as_writer(), self.quote());
+        }
+        write!(sql, " TO ").unwrap();
+        if let Some(to_name) = &rename.to_name {
+            to_name.prepare(sql.as_writer(), self.quote());
+        }
+    }
+}

src/backend/query_builder.rs

@@ -993,7 +993,10 @@ pub trait QueryBuilder: QuotedBuilder + EscapeBuilder + TableRefBuilder {
             Value::Bytes(Some(v)) => write!(
                 s,
                 "x'{}'",
-                v.iter().map(|b| format!("{:02X}", b)).collect::<String>()
+                v.iter().fold(String::new(), |mut output, b| {
+                    let _ = write!(output, "{:02X}", b);
+                    output
+                })
             )
             .unwrap(),
             #[cfg(feature = "with-json")]

src/backend/sqlite/mod.rs

@@ -2,6 +2,7 @@ pub(crate) mod foreign_key;
 pub(crate) mod index;
 pub(crate) mod query;
 pub(crate) mod table;
+pub(crate) mod view;
 
 use super::*;
 

src/backend/sqlite/view.rs

@@ -0,0 +1,49 @@
+use crate::*;
+
+impl ViewBuilder for SqliteQueryBuilder {
+    fn prepare_view_create_befor_view(
+        &self,
+        create: &ViewCreateStatement,
+        sql: &mut dyn SqlWriter,
+    ) {
+        if create.temporary {
+            write!(sql, " TEMPORARY").unwrap();
+        }
+    }
+
+    fn prepare_view_create_after_view(
+        &self,
+        create: &ViewCreateStatement,
+        sql: &mut dyn SqlWriter,
+    ) {
+        if create.if_not_exists {
+            write!(sql, " IF NOT EXISTS").unwrap();
+        }
+    }
+
+    fn prepare_view_create_opt_update(&self, _opt: &ViewCreateOpt, _sql: &mut dyn SqlWriter) {
+        // SQLite does not support view create options
+    }
+
+    fn prepare_view_rename_statement(
+        &self,
+        _rename: &ViewRenameStatement,
+        _sql: &mut dyn SqlWriter,
+    ) {
+        // SQLite does not support rename view
+    }
+
+    /// Translate [`ViewDropStatement`] into SQL statement.
+    fn prepare_view_drop_statement(&self, drop: &ViewDropStatement, sql: &mut dyn SqlWriter) {
+        write!(sql, "DROP VIEW ").unwrap();
+
+        if drop.if_exists {
+            write!(sql, "IF EXISTS ").unwrap();
+        }
+        self.prepare_view_ref(&drop.views[0], sql);
+    }
+
+    fn prepare_view_drop_opt(&self, _drop_opt: &ViewDropOpt, _sql: &mut dyn SqlWriter) {
+        // SQLite does not support view drop options
+    }
+}

src/backend/view_builder.rs

@@ -0,0 +1,122 @@
+use crate::*;
+
+pub trait ViewBuilder: QueryBuilder + QuotedBuilder {
+    /// Translate [`ViewCreateStatement`] into SQL statement.
+    fn prepare_view_create_statement(&self, create: &ViewCreateStatement, sql: &mut dyn SqlWriter) {
+        write!(sql, "CREATE").unwrap();
+        self.prepare_view_create_befor_view(create, sql);
+
+        write!(sql, " VIEW ").unwrap();
+        self.prepare_view_create_after_view(create, sql);
+
+        if let Some(view_ref) = &create.view {
+            self.prepare_view_ref(view_ref, sql);
+        }
+
+        if !create.columns.is_empty() {
+            write!(sql, " ( ").unwrap();
+            create.columns.iter().fold(true, |first, column| {
+                if !first {
+                    write!(sql, ", ").unwrap();
+                }
+                column.prepare(sql.as_writer(), self.quote());
+                false
+            });
+            write!(sql, " ) ").unwrap();
+        }
+
+        write!(sql, " AS ").unwrap();
+        // self.prepare_select_statement(create.query, sql);
+        if let Some(opt) = &create.opt {
+            self.prepare_view_create_opt_update(opt, sql);
+        }
+    }
+
+    fn prepare_view_create_befor_view(
+        &self,
+        _create: &ViewCreateStatement,
+        _sql: &mut dyn SqlWriter,
+    ) {
+    }
+
+    fn prepare_view_create_after_view(
+        &self,
+        _create: &ViewCreateStatement,
+        _sql: &mut dyn SqlWriter,
+    ) {
+    }
+
+    fn prepare_view_create_opt_update(&self, opt: &ViewCreateOpt, sql: &mut dyn SqlWriter) {
+        write!(sql, " WITH ").unwrap();
+        match opt {
+            ViewCreateOpt::Cascade => write!(sql, "CASCADED").unwrap(),
+            ViewCreateOpt::Local => write!(sql, "LOCAL").unwrap(),
+        }
+        write!(sql, " CHECK OPTION").unwrap();
+    }
+
+    fn prepare_view_rename_statement(
+        &self,
+        _rename: &ViewRenameStatement,
+        _sql: &mut dyn SqlWriter,
+    );
+
+    /// Translate [`ViewDropStatement`] into SQL statement.
+    fn prepare_view_drop_statement(&self, drop: &ViewDropStatement, sql: &mut dyn SqlWriter) {
+        write!(sql, "DROP VIEW ").unwrap();
+
+        if drop.if_exists {
+            write!(sql, "IF EXISTS ").unwrap();
+        }
+
+        drop.views.iter().fold(true, |first, view| {
+            if !first {
+                write!(sql, ", ").unwrap();
+            }
+            self.prepare_view_ref(view, sql);
+            false
+        });
+
+        let mut view_drop_opt = String::new();
+        for drop_opt in drop.options.iter() {
+            write!(&mut view_drop_opt, " ").unwrap();
+            self.prepare_view_drop_opt(drop_opt, &mut view_drop_opt);
+        }
+        write!(sql, "{}", view_drop_opt.trim_end()).unwrap();
+    }
+
+    /// Translate [`ViewDropOpt`] into SQL statement.
+    fn prepare_view_drop_opt(&self, drop_opt: &ViewDropOpt, sql: &mut dyn SqlWriter) {
+        write!(
+            sql,
+            "{}",
+            match drop_opt {
+                ViewDropOpt::Restrict => "RESTRICT",
+                ViewDropOpt::Cascade => "CASCADE",
+            }
+        )
+        .unwrap();
+    }
+
+    /// Translate [`TableRef`] into SQL statement.
+    fn prepare_view_ref(&self, table_ref: &TableRef, sql: &mut dyn SqlWriter) {
+        match table_ref {
+            TableRef::Table(table) => {
+                table.prepare(sql.as_writer(), self.quote());
+            }
+            TableRef::SchemaTable(schema, table) => {
+                schema.prepare(sql.as_writer(), self.quote());
+                write!(sql, ".").unwrap();
+                table.prepare(sql.as_writer(), self.quote());
+            }
+            TableRef::DatabaseSchemaTable(database, schema, table) => {
+                database.prepare(sql.as_writer(), self.quote());
+                write!(sql, ".").unwrap();
+                schema.prepare(sql.as_writer(), self.quote());
+                write!(sql, ".").unwrap();
+                table.prepare(sql.as_writer(), self.quote());
+            }
+            _ => panic!("Not supported"),
+        }
+    }
+}

src/extension/postgres/mod.rs

@@ -1,6 +1,5 @@
 pub use expr::*;
 pub use func::*;
-pub use interval::*;
 pub use types::*;
 
 use crate::types::BinOper;

src/lib.rs

@@ -832,6 +832,7 @@ pub mod tests_cfg;
 pub mod token;
 pub mod types;
 pub mod value;
+pub mod view;
 
 pub use backend::*;
 //pub use extension::*;
@@ -849,6 +850,7 @@ pub use schema::*;
 pub use token::*;
 pub use types::*;
 pub use value::*;
+pub use view::*;
 
 #[cfg(feature = "derive")]
 pub use sea_query_derive::{Iden, IdenStatic};

src/query/delete.rs

@@ -4,8 +4,8 @@ use crate::{
     query::{condition::*, OrderedStatement},
     types::*,
     value::*,
-    QueryStatementBuilder, QueryStatementWriter, ReturningClause, SubQueryStatement, WithClause,
-    WithQuery,
+    QueryStatementBuilder, QueryStatementWriter, ReturningClause, SubQueryBuilder,
+    SubQueryStatement, WithClause, WithQuery,
 };
 
 /// Delete existing rows from the table
@@ -231,7 +231,9 @@ impl QueryStatementBuilder for DeleteStatement {
     fn build_collect_any_into(&self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter) {
         query_builder.prepare_delete_statement(self, sql);
     }
+}
 
+impl SubQueryBuilder for DeleteStatement {
     fn into_sub_query_statement(self) -> SubQueryStatement {
         SubQueryStatement::DeleteStatement(self)
     }

src/query/insert.rs

@@ -1,7 +1,7 @@
 use crate::{
     backend::QueryBuilder, error::*, prepare::*, types::*, OnConflict, QueryStatementBuilder,
-    QueryStatementWriter, ReturningClause, SelectStatement, SimpleExpr, SubQueryStatement,
-    WithClause, WithQuery,
+    QueryStatementWriter, ReturningClause, SelectStatement, SimpleExpr, SubQueryBuilder,
+    SubQueryStatement, WithClause, WithQuery,
 };
 
 /// Represents a value source that can be used in an insert query.
@@ -521,14 +521,16 @@ impl QueryStatementBuilder for InsertStatement {
     fn build_collect_any_into(&self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter) {
         query_builder.prepare_insert_statement(self, sql);
     }
-
-    fn into_sub_query_statement(self) -> SubQueryStatement {
-        SubQueryStatement::InsertStatement(self)
-    }
 }
 
 impl QueryStatementWriter for InsertStatement {
     fn build_collect_into<T: QueryBuilder>(&self, query_builder: T, sql: &mut dyn SqlWriter) {
         query_builder.prepare_insert_statement(self, sql);
     }
 }
+
+impl SubQueryBuilder for InsertStatement {
+    fn into_sub_query_statement(self) -> SubQueryStatement {
+        SubQueryStatement::InsertStatement(self)
+    }
+}

src/query/returning.rs

@@ -21,7 +21,7 @@ pub struct Returning;
 impl Returning {
     /// Constructs a new [`Returning`].
     pub fn new() -> Self {
-        Self::default()
+        Self
     }
 
     /// Constructs a new [`ReturningClause::All`].

src/query/select.rs

@@ -5,8 +5,8 @@ use crate::{
     query::{condition::*, OrderedStatement},
     types::*,
     value::*,
-    FunctionCall, QueryStatementBuilder, QueryStatementWriter, SubQueryStatement, WindowStatement,
-    WithClause, WithQuery,
+    FunctionCall, QueryStatementBuilder, QueryStatementWriter, SubQueryBuilder, SubQueryStatement,
+    WindowStatement, WithClause, WithQuery,
 };
 
 /// Select rows from an existing table
@@ -2279,7 +2279,9 @@ impl QueryStatementBuilder for SelectStatement {
     fn build_collect_any_into(&self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter) {
         query_builder.prepare_select_statement(self, sql);
     }
+}
 
+impl SubQueryBuilder for SelectStatement {
     fn into_sub_query_statement(self) -> SubQueryStatement {
         SubQueryStatement::SelectStatement(self)
     }

src/query/traits.rs

@@ -23,7 +23,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);
+}
 
+pub trait SubQueryBuilder: Debug {
     fn into_sub_query_statement(self) -> SubQueryStatement;
 }