Add a bare select function for select statements with no from clause

In addition to this function, I have also added a `sql` function, which
is shorthand for `SqlLiteral` (but only takes `&str`, not `String`), and
`in_time_zone` which is not part of the public API.

`sql` takes `&str`, instead of `T: Into<String>`, because the first type
parameter is always going to need to be passed, and I find
`sql::<Timestamp, _>` ugly. There's always `SqlLiteral::new` if you need
to pass a `String`, or you can just deref it to `str` and accept the
copying.

I had hoped to eliminate `query_sql_params`, but there's one test we
have that's using it which requires a where clause. I can't just hack it
and do `select(sql("1 WHERE ..."))` because it uses bind params. I'll
implement `FilterDsl` for `BareSelectStatement` at some point. I'd also
like to remove `query_sql`, as I think that `select(sql` covers it
suffciently.

I've opted to leave `in_time_zone` out of the public API, as it should
actually have the return type of `Timestamptz`, and I'm really unsure
how various infix predicates with the lhs being `Timestamp` and the rhs
being `Timestamptz` are going to interact. We might be able to get away
with just not allowing it and have it be a non-issue, similarly to
`VarChar` and `Text`, but it needs further exploration.

Fixes diesel-rs#97.

Author: sgrif

CHANGELOG.md

@@ -10,6 +10,19 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 * Added support for mapping `types::Timestamp` to/from `chrono::NaiveDateTime`.
   Add `features = ["chrono"]` to enable.
 
+* Added a top level `select` function for select statements with no from clause.
+  This is primarily intended to be used for testing Diesel itself, but it has
+  been added to the public API as it will likely be useful for third party
+  crates in the future. `select(foo).from(bar)` might be a supported API in the
+  future as an alternative to `bar.select(foo)`.
+
+* Added `expression::dsl::sql` as a helper function for constructing
+  `SqlLiteral` nodes. This is primarily intended to be used for testing Diesel
+  itself, but is part of the public API as an escape hatch if our query builder
+  DSL proves inadequate for a specific case. Use of this function in any
+  production code is discouraged as it is inherently unsafe and avoids real type
+  checking.
+
 ### Changed
 
 * Rename both the `#[derive(Queriable)]` attribute and the `Queriable` trait to

diesel/src/expression/date_and_time.rs

@@ -0,0 +1,35 @@
+use expression::{Expression, SelectableExpression};
+use query_builder::{QueryBuilder, BuildQueryResult};
+use types::{Timestamp, VarChar};
+
+pub struct AtTimeZone<Ts, Tz> {
+    timestamp: Ts,
+    timezone: Tz,
+}
+
+impl<Ts, Tz> AtTimeZone<Ts, Tz> {
+    pub fn new(timestamp: Ts, timezone: Tz) -> Self {
+        AtTimeZone {
+            timestamp: timestamp,
+            timezone: timezone,
+        }
+    }
+}
+
+impl<Ts, Tz> Expression for AtTimeZone<Ts, Tz> where
+    Ts: Expression<SqlType=Timestamp>,
+    Tz: Expression<SqlType=VarChar>,
+{
+    // FIXME: This should be Timestamptz when we support that type
+    type SqlType = Timestamp;
+
+    fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
+        try!(self.timestamp.to_sql(out));
+        out.push_sql(" AT TIME ZONE ");
+        self.timezone.to_sql(out)
+    }
+}
+
+impl<Ts, Tz, Qs> SelectableExpression<Qs> for AtTimeZone<Ts, Tz> where
+    AtTimeZone<Ts, Tz>: Expression,
+{}

diesel/src/expression/expression_methods/mod.rs

@@ -7,7 +7,11 @@
 pub mod global_expression_methods;
 pub mod bool_expression_methods;
 pub mod text_expression_methods;
+#[doc(hidden)]
+pub mod timestamp_expression_methods;
 
 pub use self::global_expression_methods::ExpressionMethods;
 pub use self::bool_expression_methods::BoolExpressionMethods;
 pub use self::text_expression_methods::{TextExpressionMethods, VarCharExpressionMethods};
+#[doc(hidden)]
+pub use self::timestamp_expression_methods::TimestampExpressionMethods;

diesel/src/expression/expression_methods/timestamp_expression_methods.rs

@@ -0,0 +1,14 @@
+use expression::{AsExpression, Expression};
+use expression::date_and_time::AtTimeZone;
+use types::{VarChar, Timestamp};
+
+pub trait TimestampExpressionMethods: Expression<SqlType=Timestamp> + Sized {
+    /// Returns a PostgreSQL "AT TIME ZONE" expression
+    fn at_time_zone<T>(self, timezone: T) -> AtTimeZone<Self, T::Expression> where
+        T: AsExpression<VarChar>,
+    {
+        AtTimeZone::new(self, timezone.as_expression())
+    }
+}
+
+impl<T: Expression<SqlType=Timestamp>> TimestampExpressionMethods for T {}

diesel/src/expression/mod.rs

@@ -25,6 +25,8 @@ pub mod array_comparison;
 pub mod bound;
 #[doc(hidden)]
 pub mod count;
+#[doc(hidden)]
+pub mod date_and_time;
 pub mod expression_methods;
 pub mod extensions;
 #[doc(hidden)]
@@ -42,14 +44,11 @@ pub mod sql_literal;
 /// generic to export by default. This module exists to conveniently glob import
 /// in functions where you need them.
 pub mod dsl {
-    #[doc(inline)]
-    pub use super::array_comparison::any;
-    #[doc(inline)]
-    pub use super::count::{count, count_star};
-    #[doc(inline)]
-    pub use super::functions::date_and_time::*;
-    #[doc(inline)]
-    pub use super::functions::aggregate_ordering::*;
+    #[doc(inline)] pub use super::array_comparison::any;
+    #[doc(inline)] pub use super::count::{count, count_star};
+    #[doc(inline)] pub use super::functions::date_and_time::*;
+    #[doc(inline)] pub use super::functions::aggregate_ordering::*;
+    #[doc(inline)] pub use super::sql_literal::sql;
 
     pub use super::extensions::*;
 }

diesel/src/expression/sql_literal.rs

@@ -32,3 +32,7 @@ impl<ST: NativeSqlType> Expression for SqlLiteral<ST> {
 
 impl<QS, ST: NativeSqlType> SelectableExpression<QS> for SqlLiteral<ST> {
 }
+
+pub fn sql<ST: NativeSqlType>(sql: &str) -> SqlLiteral<ST> {
+    SqlLiteral::new(sql.into())
+}

diesel/src/lib.rs

@@ -74,7 +74,7 @@ pub mod prelude {
 pub use connection::{Connection, Cursor};
 pub use prelude::*;
 #[doc(inline)]
-pub use query_builder::functions::{insert, update, delete};
+pub use query_builder::functions::{insert, update, delete, select};
 pub use result::Error::NotFound;
 #[doc(inline)]
 pub use types::structs::data_types;

diesel/src/query_builder/bare_select_statement.rs

@@ -0,0 +1,29 @@
+use expression::SelectableExpression;
+use super::{Query, QueryFragment, QueryBuilder, BuildQueryResult};
+
+pub struct BareSelectStatement<T> {
+    expression: T,
+}
+
+impl<T> BareSelectStatement<T> {
+    pub fn new(expression: T) -> Self {
+        BareSelectStatement {
+            expression: expression,
+        }
+    }
+}
+
+impl<T> QueryFragment for BareSelectStatement<T> where
+    T: SelectableExpression<()>,
+{
+    fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
+        out.push_sql("SELECT ");
+        self.expression.to_sql(out)
+    }
+}
+
+impl<T> Query for BareSelectStatement<T> where
+    T: SelectableExpression<()>,
+{
+    type SqlType = T::SqlType;
+}

diesel/src/query_builder/functions.rs

@@ -1,5 +1,6 @@
 use super::{UpdateTarget, IncompleteUpdateStatement};
 use super::delete_statement::DeleteStatement;
+use super::BareSelectStatement;
 use super::IncompleteInsertStatement;
 
 /// Creates an update statement. Helpers for updating a single row can be
@@ -107,3 +108,14 @@ pub fn delete<T: UpdateTarget>(source: T) -> DeleteStatement<T> {
 pub fn insert<T>(records: T) -> IncompleteInsertStatement<T> {
     IncompleteInsertStatement::new(records)
 }
+
+/// Creates a bare select statement, with no from clause. Primarily used for
+/// testing diesel itself, but likely useful for third party crates as well. The
+/// given expressions must be selectable from anywhere.
+///
+/// Note: You must use `get_result` and not `first` to get a single value out of
+/// this, or you will get a vague compiler error (the reason being you cannot
+/// call `limit` on the type returned by this function).
+pub fn select<T>(expression: T) -> BareSelectStatement<T> {
+    BareSelectStatement::new(expression)
+}

diesel/src/query_builder/mod.rs

@@ -3,6 +3,7 @@
 pub mod pg;
 pub mod debug;
 
+mod bare_select_statement;
 mod delete_statement;
 #[doc(hidden)]
 pub mod functions;
@@ -14,6 +15,8 @@ mod where_clause;
 pub mod insert_statement;
 pub mod update_statement;
 
+#[doc(hidden)]
+pub use self::bare_select_statement::BareSelectStatement;
 #[doc(hidden)]
 pub use self::select_statement::SelectStatement;
 #[doc(inline)]