What is this blog series about?

But Why?

Just to give three examples which changed your life:

• Dijkstra’s letter “Go To Statement Considered Harmful” (1968) which led to consensus about basic control flow statements
• the programming language Smalltalk (Alan Kay, 1972) introducing object-oriented programming
• LISP (John McCarthy, 1958) as the first functional programming language

What is Rust?

• memory safety
• an advanced type system (with type inference)
• functional features (like closures, algebraic data types and pattern matching)
• support for asynchronous programming (async/await)
• generics and a trait system
• a module system
• a macro system
• productivity tools (for example a very helpful compiler, package manager, code formatter and documentation generator, all bundled in the tool `cargo`)

Why CAP?

Our server will

• read a compiled CDS model (in JSON representation)
• register simple generic CREATE and READ handlers
• use PostgreSQL as a database
• be super fast

A Guided Tour

Server

Let’s start with a simple web server.

There are numerous libraries/frameworks out there, this blog post gives you a good overview. I chose `tide` because it’s quite slim and I’m not using a lot of features anyway.

All Rust programs must have a `main` function which can return something called an `io::Result<()>`.

fn main() -> io::Result<()> { ... }

Error Handling

enum Result<T, E> {
   Ok(T),
   Err(E),
 }

let number_str = "10";
let number = match number_str.parse::<i32>() { // try to parse the number to an i32 (this will return a Result)
 Ok(number) => number, // if it works, extract the number
 Err(e) => return Err(e), // if not, return Err(e)
};

let number_str = "10";
let number = number_str.parse::<i32>()?;

fn main() -> io::Result<()> {
  task::block_on(async { // spawns a task and blocks the current thread on its result, now we can use `await`
    let state = State { ... }; // we can use this state object in our request handlers
    let mut app = Server::with_state(state); // start a server with state
    add_routes::add_routes(&mut app, ...); // add some routes
    let url = "127.0.0.1:8080";
    println!("Server listening on http://{}", &url);
    app.listen(&url).await?;
    Ok(())
  })
}

Rust essentially has no runtime. In contrast to Node.js, to write an async program one needs an executor from a library, this is where `task` comes from.

fn add_routes(app: &mut Server<State>, ...) -> () {
  app.at("/").get(|_req: tide::Request<State>| async move {
    Ok(
      tide::Response::new(StatusCode::Ok)
      .body_string("Please use proper routes.".to_string()),
    )
  });
}

|...| { ... }

$ cargo run

GET http://127.0.0.1:8080/

Please use proper routes.

Core Query Notation

#[derive(Debug)]
enum CQN {
  SELECT(SELECT),
  INSERT(INSERT),
}

Structs

#[derive(Debug)]
struct SELECT {
  entity: Identifier,
  columns: Vec<Identifier>,
  filter: Vec<String>,
}

Our `Identifier` is constructed to identify entities or columns.

#[derive(Debug)]
struct Identifier {
  reference: Vec<String>,
  alias: Option<String>,
}

The `Option` enum is very similar to our `Result` enum. We use it to say that this

Having a look into the Rust documentation yields:

enum Option<T> {
  None,
  Some(T),
}

impl SELECT {
  fn from(entity: &str) -> SELECT {
    SELECT {
      entity: Identifier { reference: vec![entity.to_string()], alias: None },
      columns: vec![],
      filter: vec![],
    }
  }
  ...
}

let select = SELECT::from("example_entity");

impl SELECT {
  ...
  fn columns(&mut self, columns: Vec<&str>) -> &mut Self {
    let cols: Vec<Identifier> = columns
      .iter()
      .map(|col| Identifier {
        reference: vec![col.to_string()],
        alias: None
      })
      .collect();
     self.columns.extend(cols);
     self // implicit return
  }
  ...
}

Polymorphism

trait SQL {
  fn to_sql(&self) -> String;
}

impl SQL for SELECT {
  fn to_sql(&self) -> String {
    let from_sql = &self.entity.reference.join(".").to_string().replace(".", "_");
    let mut res = match &self.columns.len() > &0 {
      true => {
        let cols: Vec<String> = self
          .columns
          .iter()
          .map(|c| c.reference.join(".").to_string())
          .collect();
        format!("SELECT {} FROM {}", cols.join(","), &from_sql)
      }
      false => format!("SELECT * FROM {}", &from_sql),
    };
    if &self.filter.len() > &0 {
      res = format!("{}{}", res, format!(" WHERE {}", &self.filter.join(" ")));
    }
    res
  }
}

fn my_function(something: &impl SQL) {
  println!("My SQL string is {}", something.to_sql());
}

Automatic Testing

#[cfg(test)] // this is our testing section
mod tests {
use super::*;
  #[test] // define a test
  fn select_with_col_to_sql() {
    let mut select = SELECT::from("example_entity");
    select.columns(vec!["col1", "col2"]);
    assert_eq!(select.to_sql(), "SELECT col1,col2 FROM example_entity")
  }
}

$ cargo test
test cqn::tests::select_with_col_to_sql ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Conclusion

We’ve seen some basic features of the Rust programming language and how easy it is so create a running server and implement some of CAP’s elements. I hope I could convince you that Rust does not feel as low level as one would expect given its high performance and that it comes with useful features and tools.

Next Steps