Make our query builder faster than a SQL string (diesel-rs#283)

We've added a new trait, `QueryId`, which must be implemented for all
AST nodes, and optionally returns a type which conforms to
`std::any::Any`. Nodes which have their SQL change without the type
changing (such as boxed nodes) will return `None` here. If we're able to
uniquely identify the query on the type alone, we use that for the cache
key rather than the SQL string. This allows us to skip the query
construction entirely. Additionally, a type identifier can be used for a
faster hash lookup than a string could, allowing us to actually beat the
string literal case.

My intent is that all types which implement `QueryFragment` also
implement `QueryId`. However, we can't make it a supertrait, as that
would require specifying the `QueryId` associated type when creating a
boxed trait object, which defeats the purpose entirely. Ironcially, we
actually implement `QueryId` for the trait object directly, so in theory
we should be able to separate them. I don't know if there's a way to
actually do this, though.

There's a handful of types which implement the "noop" form of `TypeId`
that could potentially be safe to implement for real. The main one that
comes to mind is `Aliased`. While the SQL from its implementation of
`QueryFragment` implies that the SQL can change without the type, I
think the type encapsulates enough information. It's a niche feature
though so I erred on the side of caution.

Here are the benchmark results:

```
name                                                                            old ns/iter  new ns/iter    diff ns/iter   diff %
pg::connection::tests::benchmarks::prepared_statement_lookup_query_builder      1,048        191                    -857  -81.77%
pg::connection::tests::benchmarks::prepared_statement_lookup_raw_sql            319          318                      -1   -0.31%
sqlite::connection::tests::benchmarks::prepared_statement_lookup_query_builder  743          123                    -620  -83.45%
sqlite::connection::tests::benchmarks::prepared_statement_lookup_raw_sql        183          180                      -3   -1.64%
```

These benchmarks measured creating/fetch the prepared statement, without
executing the query (calling `prepare_query` on both backends). I opted
to benchmark this as the inherent noise of a database round trip on PG
made it difficult to demonstrate the difference. The benchmarks are not
included in this PR as the code is messy and these aren't benchmarks
that I care to keep in the long term.

We could potentially gain a little bit more performance here. A type
identifier is a u64 internally, so can be used with a perfect hashing
function. This would change the lookup to be constant time. I believe
this could save us another 100 ns or so, bringing the query builder
close to 0.

Author: sgrif

diesel/src/connection/mod.rs

@@ -1,7 +1,7 @@
 extern crate libc;
 
 use backend::Backend;
-use query_builder::{AsQuery, QueryFragment};
+use query_builder::{AsQuery, QueryFragment, QueryId};
 use query_source::Queryable;
 use result::*;
 use types::HasSqlType;
@@ -69,7 +69,7 @@ pub trait Connection: SimpleConnection + Sized {
     #[doc(hidden)]
     fn query_one<T, U>(&self, source: T) -> QueryResult<U> where
         T: AsQuery,
-        T::Query: QueryFragment<Self::Backend>,
+        T::Query: QueryFragment<Self::Backend> + QueryId,
         Self::Backend: HasSqlType<T::SqlType>,
         U: Queryable<T::SqlType, Self::Backend>,
     {
@@ -80,13 +80,13 @@ pub trait Connection: SimpleConnection + Sized {
     #[doc(hidden)]
     fn query_all<T, U>(&self, source: T) -> QueryResult<Vec<U>> where
         T: AsQuery,
-        T::Query: QueryFragment<Self::Backend>,
+        T::Query: QueryFragment<Self::Backend> + QueryId,
         Self::Backend: HasSqlType<T::SqlType>,
         U: Queryable<T::SqlType, Self::Backend>;
 
     #[doc(hidden)]
     fn execute_returning_count<T>(&self, source: &T) -> QueryResult<usize> where
-        T: QueryFragment<Self::Backend>;
+        T: QueryFragment<Self::Backend> + QueryId;
 
     #[doc(hidden)] fn silence_notices<F: FnOnce() -> T, T>(&self, f: F) -> T;
     #[doc(hidden)] fn begin_transaction(&self) -> QueryResult<()>;

diesel/src/expression/aliased.rs

@@ -45,6 +45,14 @@ impl<'a, T, DB> QueryFragment<DB> for Aliased<'a, T> where
     }
 }
 
+impl<'a, T> QueryId for Aliased<'a, T> {
+    type QueryId = ();
+
+    fn has_static_query_id() -> bool {
+        false
+    }
+}
+
 // FIXME This is incorrect, should only be selectable from WithQuerySource
 impl<'a, T, QS> SelectableExpression<QS> for Aliased<'a, T> where
     Aliased<'a, T>: Expression,

diesel/src/expression/array_comparison.rs

@@ -62,6 +62,8 @@ impl<T, U, DB> QueryFragment<DB> for In<T, U> where
     }
 }
 
+impl_query_id!(In<T, U>);
+
 use std::marker::PhantomData;
 use query_builder::SelectStatement;
 
@@ -132,6 +134,8 @@ impl<T, DB> QueryFragment<DB> for Many<T> where
     }
 }
 
+impl_query_id!(noop: Many<T>);
+
 pub struct Subselect<T, ST> {
     values: T,
     _sql_type: PhantomData<ST>,
@@ -163,3 +167,5 @@ impl<T, ST, DB> QueryFragment<DB> for Subselect<T, ST> where
         self.values.is_safe_to_cache_prepared()
     }
 }
+
+impl_query_id!(Subselect<T, ST>);

diesel/src/expression/bound.rs

@@ -55,6 +55,14 @@ impl<T, U, DB> QueryFragment<DB> for Bound<T, U> where
     }
 }
 
+impl<T: QueryId, U> QueryId for Bound<T, U> {
+    type QueryId = Bound<T::QueryId, ()>;
+
+    fn has_static_query_id() -> bool {
+        T::has_static_query_id()
+    }
+}
+
 impl<T, U, QS> SelectableExpression<QS> for Bound<T, U> where
     Bound<T, U>: Expression,
 {

diesel/src/expression/count.rs

@@ -74,6 +74,8 @@ impl<T: QueryFragment<DB>, DB: Backend> QueryFragment<DB> for Count<T> {
     }
 }
 
+impl_query_id!(Count<T>);
+
 impl<T: Expression, QS> SelectableExpression<QS> for Count<T> {
 }
 
@@ -102,3 +104,5 @@ impl<DB: Backend> QueryFragment<DB> for CountStar {
 
 impl<QS> SelectableExpression<QS> for CountStar {
 }
+
+impl_query_id!(CountStar);

diesel/src/expression/functions/aggregate_folding.rs

@@ -49,6 +49,8 @@ macro_rules! fold_function {
             }
         }
 
+        impl_query_id!($type_name<T>);
+
         impl<ST, T, QS> SelectableExpression<QS> for $type_name<T> where
             ST: Foldable,
             T: Expression<SqlType=ST>,

diesel/src/expression/functions/aggregate_ordering.rs

@@ -46,6 +46,8 @@ macro_rules! ord_function {
             }
         }
 
+        impl_query_id!($type_name<T>);
+
         impl<T: Expression, QS> SelectableExpression<QS> for $type_name<T> {
         }
     }

diesel/src/expression/functions/date_and_time.rs

@@ -34,6 +34,8 @@ impl<DB: Backend> QueryFragment<DB> for now {
     }
 }
 
+impl_query_id!(now);
+
 operator_allowed!(now, Add, add);
 operator_allowed!(now, Sub, sub);
 sql_function!(date, date_t, (x: Timestamp) -> Date,

diesel/src/expression/functions/mod.rs

@@ -58,6 +58,8 @@ macro_rules! sql_function_body {
             }
         }
 
+        impl_query_id!($struct_name<$($arg_name),+>);
+
         #[allow(non_camel_case_types)]
         impl<$($arg_name),*, QS> $crate::expression::SelectableExpression<QS> for $struct_name<$($arg_name),*> where
             $($arg_name: $crate::expression::SelectableExpression<QS>,)*
@@ -134,6 +136,8 @@ macro_rules! no_arg_sql_function_body_except_to_sql {
 
         impl $crate::expression::NonAggregate for $type_name {
         }
+
+        impl_query_id!($type_name);
     }
 }
 

diesel/src/expression/grouped.rs

@@ -27,6 +27,8 @@ impl<T: QueryFragment<DB>, DB: Backend> QueryFragment<DB> for Grouped<T> {
     }
 }
 
+impl_query_id!(Grouped<T>);
+
 impl<T, QS> SelectableExpression<QS> for Grouped<T> where
     T: SelectableExpression<QS>,
     Grouped<T>: Expression,