Remove Connection::execute as it is redundant

Synphonyte · Mar 2, 2022 · 5d83a72 · 5d83a72
1 parent b7541e4
commit 5d83a72
Show file tree

Hide file tree

Showing 46 changed files with 785 additions and 689 deletions.
diff --git a/diesel/src/connection/mod.rs b/diesel/src/connection/mod.rs
@@ -365,13 +365,6 @@ where
         user_result.expect("Transaction did not succeed")
     }
 
-    /// Execute a single SQL statements within the same string and return the
-    /// number of affected rows
-    #[diesel_derives::__diesel_public_if(
-        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
-    )]
-    fn execute(&mut self, query: &str) -> QueryResult<usize>;
-
     /// Executes a given query and returns any requested values
     ///
     /// This function executes a given query and returns the

diff --git a/diesel/src/connection/transaction_manager.rs b/diesel/src/connection/transaction_manager.rs
@@ -358,10 +358,6 @@ mod test {
                 })
             }
 
-            fn execute(&mut self, _query: &str) -> QueryResult<usize> {
-                self.next_result.take().expect("No next result")
-            }
-
             fn load<'conn, 'query, T>(
                 &'conn mut self,
                 _source: T,

diff --git a/diesel/src/doctest_setup.rs b/diesel/src/doctest_setup.rs
@@ -14,60 +14,67 @@ cfg_if::cfg_if! {
         fn connection_no_data() -> PgConnection {
             let mut connection = connection_no_transaction();
             connection.begin_test_transaction().unwrap();
-            connection.execute("DROP TABLE IF EXISTS users CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS animals CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS posts CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS comments CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS brands CASCADE").unwrap();
-       
+            diesel::sql_query("DROP TABLE IF EXISTS users CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS animals CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS posts CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS comments CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS brands CASCADE").execute(&mut connection).unwrap();
+
             connection
         }
 
         #[allow(dead_code)]
         fn establish_connection() -> PgConnection {
             let mut connection = connection_no_data();
 
-            connection.execute("CREATE TABLE users (
+            diesel::sql_query("CREATE TABLE users (
                 id SERIAL PRIMARY KEY,
                 name VARCHAR NOT NULL
-            )").unwrap();
-            connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')").unwrap();
-
-            connection.execute("CREATE TABLE animals (
+            )")
+                .execute(&mut connection)
+                .unwrap();
+            diesel::sql_query("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+                .execute(&mut connection)
+                .unwrap();
+
+            diesel::sql_query("CREATE TABLE animals (
                 id SERIAL PRIMARY KEY,
                 species VARCHAR NOT NULL,
                 legs INTEGER NOT NULL,
                 name VARCHAR
-            )").unwrap();
-            connection.execute("INSERT INTO animals (species, legs, name) VALUES
+            )")
+                .execute(&mut connection)
+                .unwrap();
+            diesel::sql_query("INSERT INTO animals (species, legs, name) VALUES
                                ('dog', 4, 'Jack'),
-                               ('spider', 8, null)").unwrap();
+                               ('spider', 8, null)"
+            ).execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE posts (
+            diesel::sql_query("CREATE TABLE posts (
                 id SERIAL PRIMARY KEY,
                 user_id INTEGER NOT NULL,
                 title VARCHAR NOT NULL
-            )").unwrap();
-            connection.execute("INSERT INTO posts (user_id, title) VALUES
+            )").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO posts (user_id, title) VALUES
                 (1, 'My first post'),
                 (1, 'About Rust'),
-                (2, 'My first post too')").unwrap();
+                (2, 'My first post too')").execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE comments (
+            diesel::sql_query("CREATE TABLE comments (
                 id SERIAL PRIMARY KEY,
                 post_id INTEGER NOT NULL,
                 body VARCHAR NOT NULL
-            )").unwrap();
-            connection.execute("INSERT INTO comments (post_id, body) VALUES
+            )").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO comments (post_id, body) VALUES
                 (1, 'Great post'),
                 (2, 'Yay! I am learning Rust'),
-                (3, 'I enjoyed your post')").unwrap();
+                (3, 'I enjoyed your post')").execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE brands (
+            diesel::sql_query("CREATE TABLE brands (
                 id SERIAL PRIMARY KEY,
                 color VARCHAR NOT NULL DEFAULT 'Green',
                 accent VARCHAR DEFAULT 'Blue'
-            )").unwrap();
+            )").execute(&mut connection).unwrap();
 
             connection
         }
@@ -83,41 +90,43 @@ cfg_if::cfg_if! {
         fn establish_connection() -> SqliteConnection {
             let mut connection = connection_no_data();
 
-            connection.execute("CREATE TABLE users (
+            diesel::sql_query("CREATE TABLE users (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 name VARCHAR NOT NULL
-            )").unwrap();
-            connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')").unwrap();
+            )").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+                .execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE animals (
+            diesel::sql_query("CREATE TABLE animals (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 species VARCHAR NOT NULL,
                 legs INTEGER NOT NULL,
                 name VARCHAR
-            )").unwrap();
-            connection.execute("INSERT INTO animals (species, legs, name) VALUES
+            )").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO animals (species, legs, name) VALUES
                                ('dog', 4, 'Jack'),
-                               ('spider', 8, null)").unwrap();
+                               ('spider', 8, null)"
+            ).execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE posts (
+            diesel::sql_query("CREATE TABLE posts (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 user_id INTEGER NOT NULL,
                 title VARCHAR NOT NULL
-            )").unwrap();
-            connection.execute("INSERT INTO posts (user_id, title) VALUES
+            )").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO posts (user_id, title) VALUES
                 (1, 'My first post'),
                 (1, 'About Rust'),
-                (2, 'My first post too')").unwrap();
+                (2, 'My first post too')").execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE comments (
+            diesel::sql_query("CREATE TABLE comments (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 post_id INTEGER NOT NULL,
                 body VARCHAR NOT NULL
-            )").unwrap();
-            connection.execute("INSERT INTO comments (post_id, body) VALUES
+            )").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO comments (post_id, body) VALUES
                 (1, 'Great post'),
                 (2, 'Yay! I am learning Rust'),
-                (3, 'I enjoyed your post')").unwrap();
+                (3, 'I enjoyed your post')").execute(&mut connection).unwrap();
 
             connection
         }
@@ -128,13 +137,13 @@ cfg_if::cfg_if! {
         fn connection_no_data() -> MysqlConnection {
             let connection_url = database_url_from_env("MYSQL_UNIT_TEST_DATABASE_URL");
             let mut connection = MysqlConnection::establish(&connection_url).unwrap();
-            connection.execute("SET FOREIGN_KEY_CHECKS=0;").unwrap();
-            connection.execute("DROP TABLE IF EXISTS users CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS animals CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS posts CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS comments CASCADE").unwrap();
-            connection.execute("DROP TABLE IF EXISTS brands CASCADE").unwrap();
-            connection.execute("SET FOREIGN_KEY_CHECKS=1;").unwrap();
+            diesel::sql_query("SET FOREIGN_KEY_CHECKS=0").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS users CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS animals CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS posts CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS comments CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("DROP TABLE IF EXISTS brands CASCADE").execute(&mut connection).unwrap();
+            diesel::sql_query("SET FOREIGN_KEY_CHECKS=1").execute(&mut connection).unwrap();
 
             connection
         }
@@ -143,47 +152,48 @@ cfg_if::cfg_if! {
         fn establish_connection() -> MysqlConnection {
             let mut connection = connection_no_data();
 
-            connection.execute("CREATE TABLE users (
+            diesel::sql_query("CREATE TABLE users (
                 id INTEGER PRIMARY KEY AUTO_INCREMENT,
                 name TEXT NOT NULL
-            ) CHARACTER SET utf8mb4").unwrap();
-            connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')").unwrap();
+            ) CHARACTER SET utf8mb4").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO users (name) VALUES ('Sean'), ('Tess')")
+                      .execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE animals (
+            diesel::sql_query("CREATE TABLE animals (
                 id INTEGER PRIMARY KEY AUTO_INCREMENT,
                 species TEXT NOT NULL,
                 legs INTEGER NOT NULL,
                 name TEXT
-            ) CHARACTER SET utf8mb4").unwrap();
-            connection.execute("INSERT INTO animals (species, legs, name) VALUES
+            ) CHARACTER SET utf8mb4").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO animals (species, legs, name) VALUES
                                ('dog', 4, 'Jack'),
-                               ('spider', 8, null)").unwrap();
+                               ('spider', 8, null)").execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE posts (
+            diesel::sql_query("CREATE TABLE posts (
                 id INTEGER PRIMARY KEY AUTO_INCREMENT,
                 user_id INTEGER NOT NULL,
                 title TEXT NOT NULL
-            ) CHARACTER SET utf8mb4").unwrap();
-            connection.execute("INSERT INTO posts (user_id, title) VALUES
+            ) CHARACTER SET utf8mb4").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO posts (user_id, title) VALUES
                 (1, 'My first post'),
                 (1, 'About Rust'),
-                (2, 'My first post too')").unwrap();
+                (2, 'My first post too')").execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE comments (
+            diesel::sql_query("CREATE TABLE comments (
                 id INTEGER PRIMARY KEY AUTO_INCREMENT,
                 post_id INTEGER NOT NULL,
                 body TEXT NOT NULL
-            ) CHARACTER SET utf8mb4").unwrap();
-            connection.execute("INSERT INTO comments (post_id, body) VALUES
+            ) CHARACTER SET utf8mb4").execute(&mut connection).unwrap();
+            diesel::sql_query("INSERT INTO comments (post_id, body) VALUES
                 (1, 'Great post'),
                 (2, 'Yay! I am learning Rust'),
-                (3, 'I enjoyed your post')").unwrap();
+                (3, 'I enjoyed your post')").execute(&mut connection).unwrap();
 
-            connection.execute("CREATE TABLE brands (
+            diesel::sql_query("CREATE TABLE brands (
                 id INTEGER PRIMARY KEY AUTO_INCREMENT,
                 color VARCHAR(255) NOT NULL DEFAULT 'Green',
                 accent VARCHAR(255) DEFAULT 'Blue'
-            )").unwrap();
+            )").execute(&mut connection).unwrap();
 
             connection.begin_test_transaction().unwrap();
             connection

diff --git a/diesel/src/expression/functions/aggregate_folding.rs b/diesel/src/expression/functions/aggregate_folding.rs
@@ -48,8 +48,8 @@ sql_function! {
     /// #     use bigdecimal::BigDecimal;
     /// #     use self::numbers::dsl::*;
     /// #     let conn = &mut establish_connection();
-    /// #     conn.execute("DROP TABLE IF EXISTS numbers")?;
-    /// #     conn.execute("CREATE TABLE numbers (number INTEGER)")?;
+    /// #     diesel::sql_query("DROP TABLE IF EXISTS numbers").execute(conn)?;
+    /// #     diesel::sql_query("CREATE TABLE numbers (number INTEGER)").execute(conn)?;
     /// diesel::insert_into(numbers)
     ///     .values(&vec![number.eq(1), number.eq(2)])
     ///     .execute(conn)?;

diff --git a/diesel/src/expression/operators.rs b/diesel/src/expression/operators.rs
@@ -109,8 +109,8 @@ macro_rules! __diesel_operator_body {
 
         impl<S, $($ty_param,)+> $crate::internal::operators_macro::FieldAliasMapper<S> for $name<$($ty_param,)+>
         where
-            S: $crate::query_source::aliasing::AliasSource,
-            $($ty_param: $crate::query_source::aliasing::FieldAliasMapper<S>,)+
+            S: $crate::query_source::AliasSource,
+            $($ty_param: $crate::internal::operators_macro::FieldAliasMapper<S>,)+
         {
             type Out = $name<
                 $(<$ty_param as $crate::internal::operators_macro::FieldAliasMapper<S>>::Out,)+

diff --git a/diesel/src/expression_methods/global_expression_methods.rs b/diesel/src/expression_methods/global_expression_methods.rs
@@ -72,8 +72,8 @@ pub trait ExpressionMethods: Expression + Sized {
     /// #     use schema::users;
     /// #     use schema::posts;
     /// #     let connection = &mut establish_connection();
-    /// #     connection.execute("INSERT INTO users (name) VALUES
-    /// #         ('Jim')").unwrap();
+    /// #     diesel::sql_query("INSERT INTO users (name) VALUES
+    /// #         ('Jim')").execute(connection).unwrap();
     /// let data = users::table.select(users::id).filter(users::name.eq_any(vec!["Sean", "Jim"]));
     /// assert_eq!(Ok(vec![1, 3]), data.load(connection));
     ///
@@ -113,8 +113,8 @@ pub trait ExpressionMethods: Expression + Sized {
     /// # fn main() {
     /// #     use schema::users::dsl::*;
     /// #     let connection = &mut establish_connection();
-    /// #     connection.execute("INSERT INTO users (name) VALUES
-    /// #         ('Jim')").unwrap();
+    /// #     diesel::sql_query("INSERT INTO users (name) VALUES
+    /// #         ('Jim')").execute(connection).unwrap();
     /// let data = users.select(id).filter(name.ne_all(vec!["Sean", "Jim"]));
     /// assert_eq!(Ok(vec![2]), data.load(connection));
     ///
@@ -538,7 +538,9 @@ pub trait ExpressionMethods: Expression + Sized {
     ///     use self::users;
     ///     let connection = &mut establish_connection();
     ///
-    /// #   connection.execute("ALTER TABLE posts ADD COLUMN author_name Text").unwrap();
+    /// #   diesel::sql_query("ALTER TABLE posts ADD COLUMN author_name Text")
+    /// #       .execute(connection)
+    /// #       .unwrap();
     /// #   diesel::update(posts::table.filter(posts::user_id.eq(1)))
     /// #       .set(posts::author_name.eq("Sean"))
     /// #       .execute(connection);

diff --git a/diesel/src/expression_methods/text_expression_methods.rs b/diesel/src/expression_methods/text_expression_methods.rs
@@ -27,11 +27,11 @@ pub trait TextExpressionMethods: Expression + Sized {
     /// #     use diesel::insert_into;
     /// #
     /// #     let connection = &mut connection_no_data();
-    /// #     connection.execute("CREATE TABLE users (
+    /// #     diesel::sql_query("CREATE TABLE users (
     /// #         id INTEGER PRIMARY KEY,
     /// #         name VARCHAR(255) NOT NULL,
     /// #         hair_color VARCHAR(255)
-    /// #     )").unwrap();
+    /// #     )").execute(connection).unwrap();
     /// #
     /// #     insert_into(users)
     /// #         .values(&vec![

diff --git a/diesel/src/macros/mod.rs b/diesel/src/macros/mod.rs
@@ -74,12 +74,11 @@ macro_rules! __diesel_column {
 
         impl<DB> $crate::query_builder::QueryFragment<DB> for $column_name where
             DB: $crate::backend::Backend,
-            <$table as $crate::QuerySource>::FromClause: $crate::query_builder::QueryFragment<DB>,
+            $crate::query_builder::nodes::StaticQueryFragmentInstance<table>: $crate::query_builder::QueryFragment<DB>,
         {
             #[allow(non_snake_case)]
             fn walk_ast<'b>(&'b self, mut __out: $crate::query_builder::AstPass<'_, 'b, DB>) -> $crate::result::QueryResult<()>
             {
-                use $crate::QuerySource;
                 const FROM_CLAUSE: $crate::query_builder::nodes::StaticQueryFragmentInstance<table> = $crate::query_builder::nodes::StaticQueryFragmentInstance::new();
 
                 FROM_CLAUSE.walk_ast(__out.reborrow())?;
@@ -767,7 +766,10 @@ macro_rules! __diesel_table_impl {
                 }
             }
 
-            impl<DB> $crate::query_builder::QueryFragment<DB> for table where DB: $crate::backend::Backend {
+            impl<DB> $crate::query_builder::QueryFragment<DB> for table where
+                DB: $crate::backend::Backend,
+                <table as $crate::query_builder::nodes::StaticQueryFragment>::Component: $crate::query_builder::QueryFragment<DB>
+            {
                 fn walk_ast<'b>(&'b self, pass: $crate::query_builder::AstPass<'_, 'b, DB>) -> $crate::result::QueryResult<()> {
                     <table as $crate::query_builder::nodes::StaticQueryFragment>::STATIC_COMPONENT.walk_ast(pass)
                 }