use lower case table names (#3414)

.travis.yml

@@ -187,7 +187,7 @@ env:
      - "TESTDIR=Rust/may-minihttp"
      - "TESTDIR=Rust/tokio-minihttp"
      - "TESTDIR=Rust/rouille"
-    # - "TESTDIR=Rust/actix"
+     - "TESTDIR=Rust/actix"
      - "TESTDIR=Scala/akka-http"
      - "TESTDIR=Scala/blaze"
      - "TESTDIR=Scala/colossus"

frameworks/Rust/actix/src/db.rs

@@ -38,10 +38,10 @@ impl Handler<RandomWorld> for DbExecutor {
     type Result = io::Result<models::World>;
 
     fn handle(&mut self, _: RandomWorld, _: &mut Self::Context) -> Self::Result {
-        use schema::World::dsl::*;
+        use schema::world::dsl::*;
 
         let random_id = self.rng.gen_range(1, 10_000);
-        match World.filter(id.eq(random_id)).load::<models::World>(&self.conn) {
+        match world.filter(id.eq(random_id)).load::<models::World>(&self.conn) {
             Ok(mut items) =>
                 Ok(items.pop().unwrap()),
             Err(_) =>
@@ -60,16 +60,16 @@ impl Handler<RandomWorlds> for DbExecutor {
     type Result = io::Result<Vec<models::World>>;
 
     fn handle(&mut self, msg: RandomWorlds, _: &mut Self::Context) -> Self::Result {
-        use schema::World::dsl::*;
+        use schema::world::dsl::*;
 
         let mut worlds = Vec::with_capacity(msg.0 as usize);
         for _ in 0..msg.0 {
             let w_id = self.rng.gen_range(1, 10_000);
-            let world = match World.filter(id.eq(w_id)).load::<models::World>(&self.conn) {
+            let w = match world.filter(id.eq(w_id)).load::<models::World>(&self.conn) {
                 Ok(mut items) => items.pop().unwrap(),
                 Err(_) => return Err(io::Error::new(io::ErrorKind::Other, "Database error")),
             };
-            worlds.push(world)
+            worlds.push(w)
         }
         Ok(worlds)
     }
@@ -85,23 +85,23 @@ impl Handler<UpdateWorld> for DbExecutor {
     type Result = io::Result<Vec<models::World>>;
 
     fn handle(&mut self, msg: UpdateWorld, _: &mut Self::Context) -> Self::Result {
-        use schema::World::dsl::*;
+        use schema::world::dsl::*;
 
         let mut worlds = Vec::with_capacity(msg.0);
         for _ in 0..msg.0 {
             let w_id = self.rng.gen_range::<i32>(1, 10_000);
-            let mut world = match World.filter(id.eq(w_id)).load::<models::World>(&self.conn) {
+            let mut w = match world.filter(id.eq(w_id)).load::<models::World>(&self.conn) {
                 Ok(mut items) => items.pop().unwrap(),
                 Err(_) => return Err(io::Error::new(io::ErrorKind::Other, "Database error")),
             };
 
-            world.randomnumber = self.rng.gen_range(1, 10_000);
-            let _ = diesel::update(World)
-                .filter(id.eq(world.id))
-                .set(randomnumber.eq(world.randomnumber))
+            w.randomnumber = self.rng.gen_range(1, 10_000);
+            let _ = diesel::update(world)
+                .filter(id.eq(w.id))
+                .set(randomnumber.eq(w.randomnumber))
                 .execute(&self.conn);
 
-            worlds.push(world);
+            worlds.push(w);
         }
         Ok(worlds)
     }
@@ -117,9 +117,9 @@ impl Handler<TellFortune> for DbExecutor {
     type Result = io::Result<Vec<models::Fortune>>;
 
     fn handle(&mut self, _: TellFortune, _: &mut Self::Context) -> Self::Result {
-        use schema::Fortune::dsl::*;
+        use schema::fortune::dsl::*;
 
-        match Fortune.load::<models::Fortune>(&self.conn) {
+        match fortune.load::<models::Fortune>(&self.conn) {
             Ok(mut items) => {
                 items.push(models::Fortune{
                     id: 0,

frameworks/Rust/actix/src/main.rs

@@ -132,6 +132,9 @@ fn main() {
     let sys = System::new("techempower");
     let db_url = "postgres://benchmarkdbuser:benchmarkdbpass@TFB-database/hello_world";
 
+    // Avoid triggering "FATAL: the database system is starting up" error from postgres.
+    std::thread::sleep(std::time::Duration::from_secs(5));
+
     // Start db executor actors
     let addr = SyncArbiter::start(
         num_cpus::get() * 4, move || db::DbExecutor::new(&db_url));

frameworks/Rust/actix/src/pg.rs

@@ -170,7 +170,7 @@ impl Handler<RandomWorld> for PgConnection {
 
     fn handle(&mut self, _: RandomWorld, _: &mut Self::Context) -> Self::Result {
         let random_world = self.conn.prepare_cached(
-            "SELECT id, randomnumber FROM World WHERE id=$1").unwrap();
+            "SELECT id, randomnumber FROM world WHERE id=$1").unwrap();
 
         let random_id = self.rng.gen_range::<i32>(1, 10_000);
         for row in &random_world.query(&[&random_id]).unwrap() {
@@ -192,7 +192,7 @@ impl Handler<RandomWorlds> for PgConnection {
 
     fn handle(&mut self, msg: RandomWorlds, _: &mut Self::Context) -> Self::Result {
         let random_world = self.conn.prepare_cached(
-            "SELECT id, randomnumber FROM World WHERE id=$1").unwrap();
+            "SELECT id, randomnumber FROM world WHERE id=$1").unwrap();
 
         let mut worlds = Vec::with_capacity(msg.0 as usize);
         for _ in 0..msg.0 {
@@ -217,9 +217,9 @@ impl Handler<UpdateWorld> for PgConnection {
 
     fn handle(&mut self, msg: UpdateWorld, _: &mut Self::Context) -> Self::Result {
         let get_world = self.conn.prepare_cached(
-            "SELECT id FROM World WHERE id=$1").unwrap();
+            "SELECT id FROM world WHERE id=$1").unwrap();
         let update_world = self.conn.prepare_cached(
-            "UPDATE World SET randomnumber=$1 WHERE id=$2").unwrap();
+            "UPDATE world SET randomnumber=$1 WHERE id=$2").unwrap();
 
         let mut worlds = Vec::with_capacity(msg.0 as usize);
         for _ in 0..msg.0 {
@@ -246,7 +246,7 @@ impl Handler<TellFortune> for PgConnection {
     type Result = io::Result<Vec<Fortune>>;
 
     fn handle(&mut self, _: TellFortune, _: &mut Self::Context) -> Self::Result {
-        let fortune = self.conn.prepare_cached("SELECT id, message FROM Fortune").unwrap();
+        let fortune = self.conn.prepare_cached("SELECT id, message FROM fortune").unwrap();
 
         let mut items = Vec::with_capacity(13);
         items.push(
@@ -266,6 +266,9 @@ fn main() {
     let sys = System::new("techempower");
     let db_url = "postgres://benchmarkdbuser:benchmarkdbpass@TFB-database/hello_world";
 
+    // Avoid triggering "FATAL: the database system is starting up" error from postgres.
+    std::thread::sleep(std::time::Duration::from_secs(5));
+
     // Start db executor actors
     let addr = SyncArbiter::start(
         num_cpus::get() * 4, move || PgConnection::new(&db_url));

frameworks/Rust/actix/src/schema.rs

@@ -1,14 +1,14 @@
 #![allow(non_snake_case)]
 
 table! {
-    World (id) {
+    world (id) {
         id -> Integer,
         randomnumber -> Integer,
     }
 }
 
 table! {
-    Fortune (id) {
+    fortune (id) {
         id -> Integer,
         message -> Text,
     }