Skip to content

Instantly share code, notes, and snippets.

@comex

comex/expanded.rs

Created January 28, 2021 00:58
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save comex/e179fd701b8df2eac26dcd590c9dd0e7 to your computer and use it in GitHub Desktop.
Save comex/e179fd701b8df2eac26dcd590c9dd0e7 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
expanded.rs
// https://github.com/diesel-rs/diesel/blob/7ff5e6327d5e88095cb4b342da13bf06d6d0d1cd/examples/postgres/all_about_updates/src/lib.rs
// after running through `cargo expand`
#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
use std::time::SystemTime;
use diesel::prelude::*;
pub mod posts {
#![allow(dead_code)]
use ::diesel::sql_types::*;
pub use self::columns::*;
/// Re-exports all of the columns of this table, as well as the
/// table struct renamed to the module name. This is meant to be
/// glob imported for functions which only deal with one table.
pub mod dsl {
pub use super::columns::{id};
pub use super::columns::{title};
pub use super::columns::{body};
pub use super::columns::{draft};
pub use super::columns::{publish_at};
pub use super::columns::{visit_count};
pub use super::table as posts;
}
#[allow(non_upper_case_globals, dead_code)]
/// A tuple of all of the columns on this table
pub const all_columns: (id, title, body, draft, publish_at, visit_count) =
(id, title, body, draft, publish_at, visit_count);
#[allow(non_camel_case_types)]
/// The actual table struct
///
/// This is the type which provides the base methods of the query
/// builder, such as `.select` and `.filter`.
pub struct table;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
impl ::core::fmt::Debug for table {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
table => {
let mut debug_trait_builder = f.debug_tuple("table");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
impl ::core::clone::Clone for table {
#[inline]
fn clone(&self) -> table {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
impl ::core::marker::Copy for table {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for table {
type QueryId = table;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
impl table {
#[allow(dead_code)]
/// Represents `table_name.*`, which is sometimes necessary
/// for efficient count queries. It cannot be used in place of
/// `all_columns`
pub fn star(&self) -> star {
star
}
}
/// The SQL type of all of the columns on this table
pub type SqlType = (BigInt, Text, Text, Bool, Timestamp, Integer);
/// Helper type for representing a boxed query from this table
pub type BoxedQuery<'a, DB, ST = SqlType> =
::diesel::query_builder::BoxedSelectStatement<'a, ST, table, DB>;
impl ::diesel::QuerySource for table {
type FromClause = ::diesel::query_builder::nodes::Identifier<'static>;
type DefaultSelection = <Self as ::diesel::Table>::AllColumns;
fn from_clause(&self) -> Self::FromClause {
::diesel::query_builder::nodes::Identifier("posts")
}
fn default_selection(&self) -> Self::DefaultSelection {
use ::diesel::Table;
Self::all_columns()
}
}
impl ::diesel::query_builder::AsQuery for table {
type SqlType = SqlType;
type Query = ::diesel::query_builder::SelectStatement<Self>;
fn as_query(self) -> Self::Query {
::diesel::query_builder::SelectStatement::simple(self)
}
}
impl ::diesel::Table for table {
type PrimaryKey = id;
type AllColumns = (id, title, body, draft, publish_at, visit_count);
fn primary_key(&self) -> Self::PrimaryKey {
id
}
fn all_columns() -> Self::AllColumns {
(id, title, body, draft, publish_at, visit_count)
}
}
impl ::diesel::associations::HasTable for table {
type Table = Self;
fn table() -> Self::Table {
table
}
}
impl ::diesel::query_builder::IntoUpdateTarget for table {
type WhereClause = < < Self as :: diesel :: query_builder :: AsQuery > :: Query as :: diesel :: query_builder :: IntoUpdateTarget > :: WhereClause ;
fn into_update_target(
self,
) -> ::diesel::query_builder::UpdateTarget<Self::Table, Self::WhereClause> {
use ::diesel::query_builder::AsQuery;
self.as_query().into_update_target()
}
}
impl ::diesel::query_source::AppearsInFromClause<table> for table {
type Count = ::diesel::query_source::Once;
}
impl ::diesel::query_source::AppearsInFromClause<table> for () {
type Count = ::diesel::query_source::Never;
}
impl<Left, Right, Kind> ::diesel::JoinTo<::diesel::query_source::joins::Join<Left, Right, Kind>>
for table
where
::diesel::query_source::joins::Join<Left, Right, Kind>: ::diesel::JoinTo<table>,
{
type FromClause = ::diesel::query_source::joins::Join<Left, Right, Kind>;
type OnClause = < :: diesel :: query_source :: joins :: Join < Left , Right , Kind > as :: diesel :: JoinTo < table > > :: OnClause ;
fn join_target(
rhs: ::diesel::query_source::joins::Join<Left, Right, Kind>,
) -> (Self::FromClause, Self::OnClause) {
let (_, on_clause) = ::diesel::query_source::joins::Join::join_target(table);
(rhs, on_clause)
}
}
impl<Join, On> ::diesel::JoinTo<::diesel::query_source::joins::JoinOn<Join, On>> for table
where
::diesel::query_source::joins::JoinOn<Join, On>: ::diesel::JoinTo<table>,
{
type FromClause = ::diesel::query_source::joins::JoinOn<Join, On>;
type OnClause =
<::diesel::query_source::joins::JoinOn<Join, On> as ::diesel::JoinTo<table>>::OnClause;
fn join_target(
rhs: ::diesel::query_source::joins::JoinOn<Join, On>,
) -> (Self::FromClause, Self::OnClause) {
let (_, on_clause) = ::diesel::query_source::joins::JoinOn::join_target(table);
(rhs, on_clause)
}
}
impl<F, S, D, W, O, L, Of, G>
::diesel::JoinTo<::diesel::query_builder::SelectStatement<F, S, D, W, O, L, Of, G>>
for table
where
::diesel::query_builder::SelectStatement<F, S, D, W, O, L, Of, G>: ::diesel::JoinTo<table>,
{
type FromClause = ::diesel::query_builder::SelectStatement<F, S, D, W, O, L, Of, G>;
type OnClause = < :: diesel :: query_builder :: SelectStatement < F , S , D , W , O , L , Of , G > as :: diesel :: JoinTo < table > > :: OnClause ;
fn join_target(
rhs: ::diesel::query_builder::SelectStatement<F, S, D, W, O, L, Of, G>,
) -> (Self::FromClause, Self::OnClause) {
let (_, on_clause) = ::diesel::query_builder::SelectStatement::join_target(table);
(rhs, on_clause)
}
}
impl<'a, QS, ST, DB>
::diesel::JoinTo<::diesel::query_builder::BoxedSelectStatement<'a, QS, ST, DB>> for table
where
::diesel::query_builder::BoxedSelectStatement<'a, QS, ST, DB>: ::diesel::JoinTo<table>,
{
type FromClause = ::diesel::query_builder::BoxedSelectStatement<'a, QS, ST, DB>;
type OnClause =
<::diesel::query_builder::BoxedSelectStatement<'a, QS, ST, DB> as ::diesel::JoinTo<
table,
>>::OnClause;
fn join_target(
rhs: ::diesel::query_builder::BoxedSelectStatement<'a, QS, ST, DB>,
) -> (Self::FromClause, Self::OnClause) {
let (_, on_clause) = ::diesel::query_builder::BoxedSelectStatement::join_target(table);
(rhs, on_clause)
}
}
impl<T> ::diesel::insertable::Insertable<T> for table
where
<table as ::diesel::query_builder::AsQuery>::Query: ::diesel::insertable::Insertable<T>,
{
type Values = < < table as :: diesel :: query_builder :: AsQuery > :: Query as :: diesel :: insertable :: Insertable < T > > :: Values ;
fn values(self) -> Self::Values {
use ::diesel::query_builder::AsQuery;
self.as_query().values()
}
}
impl<'a, T> ::diesel::insertable::Insertable<T> for &'a table
where
table: ::diesel::insertable::Insertable<T>,
{
type Values = <table as ::diesel::insertable::Insertable<T>>::Values;
fn values(self) -> Self::Values {
(*self).values()
}
}
/// Contains all of the columns of this table
pub mod columns {
use super::table;
use ::diesel::sql_types::*;
#[allow(non_camel_case_types, dead_code)]
/// Represents `table_name.*`, which is sometimes needed for
/// efficient count queries. It cannot be used in place of
/// `all_columns`, and has a `SqlType` of `()` to prevent it
/// being used that way
pub struct star;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::fmt::Debug for star {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
star => {
let mut debug_trait_builder = f.debug_tuple("star");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::clone::Clone for star {
#[inline]
fn clone(&self) -> star {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::marker::Copy for star {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for star {
type QueryId = star;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
impl<__GB> ::diesel::expression::ValidGrouping<__GB> for star
where
(id, title, body, draft, publish_at, visit_count):
::diesel::expression::ValidGrouping<__GB>,
{
type IsAggregate = < ( id , title , body , draft , publish_at , visit_count ) as :: diesel :: expression :: ValidGrouping < __GB > > :: IsAggregate ;
}
impl ::diesel::Expression for star {
type SqlType = ::diesel::expression::expression_types::NotSelectable;
}
impl<DB: ::diesel::backend::Backend> ::diesel::query_builder::QueryFragment<DB> for star
where
<table as ::diesel::QuerySource>::FromClause:
::diesel::query_builder::QueryFragment<DB>,
{
#[allow(non_snake_case)]
fn walk_ast(
&self,
mut __out: ::diesel::query_builder::AstPass<DB>,
) -> ::diesel::result::QueryResult<()> {
use ::diesel::QuerySource;
table.from_clause().walk_ast(__out.reborrow())?;
__out.push_sql(".*");
Ok(())
}
}
impl ::diesel::SelectableExpression<table> for star {}
impl ::diesel::AppearsOnTable<table> for star {}
#[allow(non_camel_case_types, dead_code)]
pub struct id;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::fmt::Debug for id {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
id => {
let mut debug_trait_builder = f.debug_tuple("id");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::clone::Clone for id {
#[inline]
fn clone(&self) -> id {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::marker::Copy for id {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for id {
type QueryId = id;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::default::Default for id {
#[inline]
fn default() -> id {
id {}
}
}
impl ::diesel::expression::Expression for id {
type SqlType = BigInt;
}
impl<DB> ::diesel::query_builder::QueryFragment<DB> for id
where
DB: ::diesel::backend::Backend,
<table as ::diesel::QuerySource>::FromClause:
::diesel::query_builder::QueryFragment<DB>,
{
#[allow(non_snake_case)]
fn walk_ast(
&self,
mut __out: ::diesel::query_builder::AstPass<DB>,
) -> ::diesel::result::QueryResult<()> {
use ::diesel::QuerySource;
table.from_clause().walk_ast(__out.reborrow())?;
__out.push_sql(".");
__out.push_identifier("id")
}
}
impl ::diesel::SelectableExpression<table> for id {}
impl<QS> ::diesel::AppearsOnTable<QS> for id where
QS: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Once,
>
{
}
impl<Left, Right>
::diesel::SelectableExpression<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
> for id
where
id: ::diesel::AppearsOnTable<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
>,
Self: ::diesel::SelectableExpression<Left>,
Right: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Never,
>,
{
}
impl < Left , Right > :: diesel :: SelectableExpression < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > for id where id : :: diesel :: AppearsOnTable < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > , Left : :: diesel :: query_source :: AppearsInFromClause < table > , Right : :: diesel :: query_source :: AppearsInFromClause < table > , ( Left :: Count , Right :: Count ) : :: diesel :: query_source :: Pick < Left , Right > , Self : :: diesel :: SelectableExpression < < ( Left :: Count , Right :: Count ) as :: diesel :: query_source :: Pick < Left , Right > > :: Selection > { }
impl<Join, On>
::diesel::SelectableExpression<::diesel::query_source::joins::JoinOn<Join, On>> for id
where
id: ::diesel::SelectableExpression<Join>
+ ::diesel::AppearsOnTable<::diesel::query_source::joins::JoinOn<Join, On>>,
{
}
impl<From> ::diesel::SelectableExpression<::diesel::query_builder::SelectStatement<From>> for id where
id: ::diesel::SelectableExpression<From>
+ ::diesel::AppearsOnTable<::diesel::query_builder::SelectStatement<From>>
{
}
impl<__GB> ::diesel::expression::ValidGrouping<__GB> for id
where
__GB: ::diesel::expression::IsContainedInGroupBy<
id,
Output = ::diesel::expression::is_contained_in_group_by::Yes,
>,
{
type IsAggregate = ::diesel::expression::is_aggregate::Yes;
}
impl ::diesel::expression::ValidGrouping<()> for id {
type IsAggregate = ::diesel::expression::is_aggregate::No;
}
impl ::diesel::expression::IsContainedInGroupBy<id> for id {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::query_source::Column for id {
type Table = table;
const NAME: &'static str = "id";
}
impl<T> ::diesel::EqAll<T> for id
where
T: ::diesel::expression::AsExpression<BigInt>,
::diesel::dsl::Eq<id, T::Expression>:
::diesel::Expression<SqlType = ::diesel::sql_types::Bool>,
{
type Output = ::diesel::dsl::Eq<Self, T::Expression>;
fn eq_all(self, rhs: T) -> Self::Output {
use ::diesel::expression_methods::ExpressionMethods;
self.eq(rhs)
}
}
impl<Rhs> ::std::ops::Add<Rhs> for id
where
Rhs: ::diesel::expression::AsExpression<
<<id as ::diesel::Expression>::SqlType as ::diesel::sql_types::ops::Add>::Rhs,
>,
{
type Output = ::diesel::expression::ops::Add<Self, Rhs::Expression>;
fn add(self, rhs: Rhs) -> Self::Output {
::diesel::expression::ops::Add::new(self, rhs.as_expression())
}
}
impl<Rhs> ::std::ops::Sub<Rhs> for id
where
Rhs: ::diesel::expression::AsExpression<
<<id as ::diesel::Expression>::SqlType as ::diesel::sql_types::ops::Sub>::Rhs,
>,
{
type Output = ::diesel::expression::ops::Sub<Self, Rhs::Expression>;
fn sub(self, rhs: Rhs) -> Self::Output {
::diesel::expression::ops::Sub::new(self, rhs.as_expression())
}
}
impl<Rhs> ::std::ops::Div<Rhs> for id
where
Rhs: ::diesel::expression::AsExpression<
<<id as ::diesel::Expression>::SqlType as ::diesel::sql_types::ops::Div>::Rhs,
>,
{
type Output = ::diesel::expression::ops::Div<Self, Rhs::Expression>;
fn div(self, rhs: Rhs) -> Self::Output {
::diesel::expression::ops::Div::new(self, rhs.as_expression())
}
}
impl<Rhs> ::std::ops::Mul<Rhs> for id
where
Rhs: ::diesel::expression::AsExpression<
<<id as ::diesel::Expression>::SqlType as ::diesel::sql_types::ops::Mul>::Rhs,
>,
{
type Output = ::diesel::expression::ops::Mul<Self, Rhs::Expression>;
fn mul(self, rhs: Rhs) -> Self::Output {
::diesel::expression::ops::Mul::new(self, rhs.as_expression())
}
}
#[allow(non_camel_case_types, dead_code)]
pub struct title;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::fmt::Debug for title {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
title => {
let mut debug_trait_builder = f.debug_tuple("title");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::clone::Clone for title {
#[inline]
fn clone(&self) -> title {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::marker::Copy for title {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for title {
type QueryId = title;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::default::Default for title {
#[inline]
fn default() -> title {
title {}
}
}
impl ::diesel::expression::Expression for title {
type SqlType = Text;
}
impl<DB> ::diesel::query_builder::QueryFragment<DB> for title
where
DB: ::diesel::backend::Backend,
<table as ::diesel::QuerySource>::FromClause:
::diesel::query_builder::QueryFragment<DB>,
{
#[allow(non_snake_case)]
fn walk_ast(
&self,
mut __out: ::diesel::query_builder::AstPass<DB>,
) -> ::diesel::result::QueryResult<()> {
use ::diesel::QuerySource;
table.from_clause().walk_ast(__out.reborrow())?;
__out.push_sql(".");
__out.push_identifier("title")
}
}
impl ::diesel::SelectableExpression<table> for title {}
impl<QS> ::diesel::AppearsOnTable<QS> for title where
QS: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Once,
>
{
}
impl<Left, Right>
::diesel::SelectableExpression<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
> for title
where
title: ::diesel::AppearsOnTable<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
>,
Self: ::diesel::SelectableExpression<Left>,
Right: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Never,
>,
{
}
impl < Left , Right > :: diesel :: SelectableExpression < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > for title where title : :: diesel :: AppearsOnTable < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > , Left : :: diesel :: query_source :: AppearsInFromClause < table > , Right : :: diesel :: query_source :: AppearsInFromClause < table > , ( Left :: Count , Right :: Count ) : :: diesel :: query_source :: Pick < Left , Right > , Self : :: diesel :: SelectableExpression < < ( Left :: Count , Right :: Count ) as :: diesel :: query_source :: Pick < Left , Right > > :: Selection > { }
impl<Join, On>
::diesel::SelectableExpression<::diesel::query_source::joins::JoinOn<Join, On>>
for title
where
title: ::diesel::SelectableExpression<Join>
+ ::diesel::AppearsOnTable<::diesel::query_source::joins::JoinOn<Join, On>>,
{
}
impl<From> ::diesel::SelectableExpression<::diesel::query_builder::SelectStatement<From>> for title where
title: ::diesel::SelectableExpression<From>
+ ::diesel::AppearsOnTable<::diesel::query_builder::SelectStatement<From>>
{
}
impl<__GB> ::diesel::expression::ValidGrouping<__GB> for title
where
__GB: ::diesel::expression::IsContainedInGroupBy<
title,
Output = ::diesel::expression::is_contained_in_group_by::Yes,
>,
{
type IsAggregate = ::diesel::expression::is_aggregate::Yes;
}
impl ::diesel::expression::ValidGrouping<()> for title {
type IsAggregate = ::diesel::expression::is_aggregate::No;
}
impl ::diesel::expression::IsContainedInGroupBy<title> for title {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::query_source::Column for title {
type Table = table;
const NAME: &'static str = "title";
}
impl<T> ::diesel::EqAll<T> for title
where
T: ::diesel::expression::AsExpression<Text>,
::diesel::dsl::Eq<title, T::Expression>:
::diesel::Expression<SqlType = ::diesel::sql_types::Bool>,
{
type Output = ::diesel::dsl::Eq<Self, T::Expression>;
fn eq_all(self, rhs: T) -> Self::Output {
use ::diesel::expression_methods::ExpressionMethods;
self.eq(rhs)
}
}
#[allow(non_camel_case_types, dead_code)]
pub struct body;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::fmt::Debug for body {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
body => {
let mut debug_trait_builder = f.debug_tuple("body");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::clone::Clone for body {
#[inline]
fn clone(&self) -> body {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::marker::Copy for body {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for body {
type QueryId = body;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::default::Default for body {
#[inline]
fn default() -> body {
body {}
}
}
impl ::diesel::expression::Expression for body {
type SqlType = Text;
}
impl<DB> ::diesel::query_builder::QueryFragment<DB> for body
where
DB: ::diesel::backend::Backend,
<table as ::diesel::QuerySource>::FromClause:
::diesel::query_builder::QueryFragment<DB>,
{
#[allow(non_snake_case)]
fn walk_ast(
&self,
mut __out: ::diesel::query_builder::AstPass<DB>,
) -> ::diesel::result::QueryResult<()> {
use ::diesel::QuerySource;
table.from_clause().walk_ast(__out.reborrow())?;
__out.push_sql(".");
__out.push_identifier("body")
}
}
impl ::diesel::SelectableExpression<table> for body {}
impl<QS> ::diesel::AppearsOnTable<QS> for body where
QS: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Once,
>
{
}
impl<Left, Right>
::diesel::SelectableExpression<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
> for body
where
body: ::diesel::AppearsOnTable<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
>,
Self: ::diesel::SelectableExpression<Left>,
Right: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Never,
>,
{
}
impl < Left , Right > :: diesel :: SelectableExpression < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > for body where body : :: diesel :: AppearsOnTable < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > , Left : :: diesel :: query_source :: AppearsInFromClause < table > , Right : :: diesel :: query_source :: AppearsInFromClause < table > , ( Left :: Count , Right :: Count ) : :: diesel :: query_source :: Pick < Left , Right > , Self : :: diesel :: SelectableExpression < < ( Left :: Count , Right :: Count ) as :: diesel :: query_source :: Pick < Left , Right > > :: Selection > { }
impl<Join, On>
::diesel::SelectableExpression<::diesel::query_source::joins::JoinOn<Join, On>> for body
where
body: ::diesel::SelectableExpression<Join>
+ ::diesel::AppearsOnTable<::diesel::query_source::joins::JoinOn<Join, On>>,
{
}
impl<From> ::diesel::SelectableExpression<::diesel::query_builder::SelectStatement<From>> for body where
body: ::diesel::SelectableExpression<From>
+ ::diesel::AppearsOnTable<::diesel::query_builder::SelectStatement<From>>
{
}
impl<__GB> ::diesel::expression::ValidGrouping<__GB> for body
where
__GB: ::diesel::expression::IsContainedInGroupBy<
body,
Output = ::diesel::expression::is_contained_in_group_by::Yes,
>,
{
type IsAggregate = ::diesel::expression::is_aggregate::Yes;
}
impl ::diesel::expression::ValidGrouping<()> for body {
type IsAggregate = ::diesel::expression::is_aggregate::No;
}
impl ::diesel::expression::IsContainedInGroupBy<body> for body {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::query_source::Column for body {
type Table = table;
const NAME: &'static str = "body";
}
impl<T> ::diesel::EqAll<T> for body
where
T: ::diesel::expression::AsExpression<Text>,
::diesel::dsl::Eq<body, T::Expression>:
::diesel::Expression<SqlType = ::diesel::sql_types::Bool>,
{
type Output = ::diesel::dsl::Eq<Self, T::Expression>;
fn eq_all(self, rhs: T) -> Self::Output {
use ::diesel::expression_methods::ExpressionMethods;
self.eq(rhs)
}
}
#[allow(non_camel_case_types, dead_code)]
pub struct draft;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::fmt::Debug for draft {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
draft => {
let mut debug_trait_builder = f.debug_tuple("draft");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::clone::Clone for draft {
#[inline]
fn clone(&self) -> draft {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::marker::Copy for draft {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for draft {
type QueryId = draft;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::default::Default for draft {
#[inline]
fn default() -> draft {
draft {}
}
}
impl ::diesel::expression::Expression for draft {
type SqlType = Bool;
}
impl<DB> ::diesel::query_builder::QueryFragment<DB> for draft
where
DB: ::diesel::backend::Backend,
<table as ::diesel::QuerySource>::FromClause:
::diesel::query_builder::QueryFragment<DB>,
{
#[allow(non_snake_case)]
fn walk_ast(
&self,
mut __out: ::diesel::query_builder::AstPass<DB>,
) -> ::diesel::result::QueryResult<()> {
use ::diesel::QuerySource;
table.from_clause().walk_ast(__out.reborrow())?;
__out.push_sql(".");
__out.push_identifier("draft")
}
}
impl ::diesel::SelectableExpression<table> for draft {}
impl<QS> ::diesel::AppearsOnTable<QS> for draft where
QS: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Once,
>
{
}
impl<Left, Right>
::diesel::SelectableExpression<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
> for draft
where
draft: ::diesel::AppearsOnTable<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
>,
Self: ::diesel::SelectableExpression<Left>,
Right: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Never,
>,
{
}
impl < Left , Right > :: diesel :: SelectableExpression < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > for draft where draft : :: diesel :: AppearsOnTable < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > , Left : :: diesel :: query_source :: AppearsInFromClause < table > , Right : :: diesel :: query_source :: AppearsInFromClause < table > , ( Left :: Count , Right :: Count ) : :: diesel :: query_source :: Pick < Left , Right > , Self : :: diesel :: SelectableExpression < < ( Left :: Count , Right :: Count ) as :: diesel :: query_source :: Pick < Left , Right > > :: Selection > { }
impl<Join, On>
::diesel::SelectableExpression<::diesel::query_source::joins::JoinOn<Join, On>>
for draft
where
draft: ::diesel::SelectableExpression<Join>
+ ::diesel::AppearsOnTable<::diesel::query_source::joins::JoinOn<Join, On>>,
{
}
impl<From> ::diesel::SelectableExpression<::diesel::query_builder::SelectStatement<From>> for draft where
draft: ::diesel::SelectableExpression<From>
+ ::diesel::AppearsOnTable<::diesel::query_builder::SelectStatement<From>>
{
}
impl<__GB> ::diesel::expression::ValidGrouping<__GB> for draft
where
__GB: ::diesel::expression::IsContainedInGroupBy<
draft,
Output = ::diesel::expression::is_contained_in_group_by::Yes,
>,
{
type IsAggregate = ::diesel::expression::is_aggregate::Yes;
}
impl ::diesel::expression::ValidGrouping<()> for draft {
type IsAggregate = ::diesel::expression::is_aggregate::No;
}
impl ::diesel::expression::IsContainedInGroupBy<draft> for draft {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::query_source::Column for draft {
type Table = table;
const NAME: &'static str = "draft";
}
impl<T> ::diesel::EqAll<T> for draft
where
T: ::diesel::expression::AsExpression<Bool>,
::diesel::dsl::Eq<draft, T::Expression>:
::diesel::Expression<SqlType = ::diesel::sql_types::Bool>,
{
type Output = ::diesel::dsl::Eq<Self, T::Expression>;
fn eq_all(self, rhs: T) -> Self::Output {
use ::diesel::expression_methods::ExpressionMethods;
self.eq(rhs)
}
}
#[allow(non_camel_case_types, dead_code)]
pub struct publish_at;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::fmt::Debug for publish_at {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
publish_at => {
let mut debug_trait_builder = f.debug_tuple("publish_at");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::clone::Clone for publish_at {
#[inline]
fn clone(&self) -> publish_at {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::marker::Copy for publish_at {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for publish_at {
type QueryId = publish_at;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::default::Default for publish_at {
#[inline]
fn default() -> publish_at {
publish_at {}
}
}
impl ::diesel::expression::Expression for publish_at {
type SqlType = Timestamp;
}
impl<DB> ::diesel::query_builder::QueryFragment<DB> for publish_at
where
DB: ::diesel::backend::Backend,
<table as ::diesel::QuerySource>::FromClause:
::diesel::query_builder::QueryFragment<DB>,
{
#[allow(non_snake_case)]
fn walk_ast(
&self,
mut __out: ::diesel::query_builder::AstPass<DB>,
) -> ::diesel::result::QueryResult<()> {
use ::diesel::QuerySource;
table.from_clause().walk_ast(__out.reborrow())?;
__out.push_sql(".");
__out.push_identifier("publish_at")
}
}
impl ::diesel::SelectableExpression<table> for publish_at {}
impl<QS> ::diesel::AppearsOnTable<QS> for publish_at where
QS: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Once,
>
{
}
impl<Left, Right>
::diesel::SelectableExpression<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
> for publish_at
where
publish_at: ::diesel::AppearsOnTable<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
>,
Self: ::diesel::SelectableExpression<Left>,
Right: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Never,
>,
{
}
impl < Left , Right > :: diesel :: SelectableExpression < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > for publish_at where publish_at : :: diesel :: AppearsOnTable < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > , Left : :: diesel :: query_source :: AppearsInFromClause < table > , Right : :: diesel :: query_source :: AppearsInFromClause < table > , ( Left :: Count , Right :: Count ) : :: diesel :: query_source :: Pick < Left , Right > , Self : :: diesel :: SelectableExpression < < ( Left :: Count , Right :: Count ) as :: diesel :: query_source :: Pick < Left , Right > > :: Selection > { }
impl<Join, On>
::diesel::SelectableExpression<::diesel::query_source::joins::JoinOn<Join, On>>
for publish_at
where
publish_at: ::diesel::SelectableExpression<Join>
+ ::diesel::AppearsOnTable<::diesel::query_source::joins::JoinOn<Join, On>>,
{
}
impl<From> ::diesel::SelectableExpression<::diesel::query_builder::SelectStatement<From>>
for publish_at
where
publish_at: ::diesel::SelectableExpression<From>
+ ::diesel::AppearsOnTable<::diesel::query_builder::SelectStatement<From>>,
{
}
impl<__GB> ::diesel::expression::ValidGrouping<__GB> for publish_at
where
__GB: ::diesel::expression::IsContainedInGroupBy<
publish_at,
Output = ::diesel::expression::is_contained_in_group_by::Yes,
>,
{
type IsAggregate = ::diesel::expression::is_aggregate::Yes;
}
impl ::diesel::expression::ValidGrouping<()> for publish_at {
type IsAggregate = ::diesel::expression::is_aggregate::No;
}
impl ::diesel::expression::IsContainedInGroupBy<publish_at> for publish_at {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::query_source::Column for publish_at {
type Table = table;
const NAME: &'static str = "publish_at";
}
impl<T> ::diesel::EqAll<T> for publish_at
where
T: ::diesel::expression::AsExpression<Timestamp>,
::diesel::dsl::Eq<publish_at, T::Expression>:
::diesel::Expression<SqlType = ::diesel::sql_types::Bool>,
{
type Output = ::diesel::dsl::Eq<Self, T::Expression>;
fn eq_all(self, rhs: T) -> Self::Output {
use ::diesel::expression_methods::ExpressionMethods;
self.eq(rhs)
}
}
impl < Rhs > :: std :: ops :: Add < Rhs > for publish_at where Rhs : :: diesel :: expression :: AsExpression < < < publish_at as :: diesel :: Expression > :: SqlType as :: diesel :: sql_types :: ops :: Add > :: Rhs > { type Output = :: diesel :: expression :: ops :: Add < Self , Rhs :: Expression > ; fn add ( self , rhs : Rhs ) -> Self :: Output { :: diesel :: expression :: ops :: Add :: new ( self , rhs . as_expression ( ) ) } }
impl < Rhs > :: std :: ops :: Sub < Rhs > for publish_at where Rhs : :: diesel :: expression :: AsExpression < < < publish_at as :: diesel :: Expression > :: SqlType as :: diesel :: sql_types :: ops :: Sub > :: Rhs > { type Output = :: diesel :: expression :: ops :: Sub < Self , Rhs :: Expression > ; fn sub ( self , rhs : Rhs ) -> Self :: Output { :: diesel :: expression :: ops :: Sub :: new ( self , rhs . as_expression ( ) ) } }
#[allow(non_camel_case_types, dead_code)]
pub struct visit_count;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::fmt::Debug for visit_count {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
visit_count => {
let mut debug_trait_builder = f.debug_tuple("visit_count");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::clone::Clone for visit_count {
#[inline]
fn clone(&self) -> visit_count {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::marker::Copy for visit_count {}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::QueryId;
#[allow(non_camel_case_types)]
impl QueryId for visit_count {
type QueryId = visit_count;
const HAS_STATIC_QUERY_ID: bool = true;
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types, dead_code)]
impl ::core::default::Default for visit_count {
#[inline]
fn default() -> visit_count {
visit_count {}
}
}
impl ::diesel::expression::Expression for visit_count {
type SqlType = Integer;
}
impl<DB> ::diesel::query_builder::QueryFragment<DB> for visit_count
where
DB: ::diesel::backend::Backend,
<table as ::diesel::QuerySource>::FromClause:
::diesel::query_builder::QueryFragment<DB>,
{
#[allow(non_snake_case)]
fn walk_ast(
&self,
mut __out: ::diesel::query_builder::AstPass<DB>,
) -> ::diesel::result::QueryResult<()> {
use ::diesel::QuerySource;
table.from_clause().walk_ast(__out.reborrow())?;
__out.push_sql(".");
__out.push_identifier("visit_count")
}
}
impl ::diesel::SelectableExpression<table> for visit_count {}
impl<QS> ::diesel::AppearsOnTable<QS> for visit_count where
QS: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Once,
>
{
}
impl<Left, Right>
::diesel::SelectableExpression<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
> for visit_count
where
visit_count: ::diesel::AppearsOnTable<
::diesel::query_source::joins::Join<
Left,
Right,
::diesel::query_source::joins::LeftOuter,
>,
>,
Self: ::diesel::SelectableExpression<Left>,
Right: ::diesel::query_source::AppearsInFromClause<
table,
Count = ::diesel::query_source::Never,
>,
{
}
impl < Left , Right > :: diesel :: SelectableExpression < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > for visit_count where visit_count : :: diesel :: AppearsOnTable < :: diesel :: query_source :: joins :: Join < Left , Right , :: diesel :: query_source :: joins :: Inner > > , Left : :: diesel :: query_source :: AppearsInFromClause < table > , Right : :: diesel :: query_source :: AppearsInFromClause < table > , ( Left :: Count , Right :: Count ) : :: diesel :: query_source :: Pick < Left , Right > , Self : :: diesel :: SelectableExpression < < ( Left :: Count , Right :: Count ) as :: diesel :: query_source :: Pick < Left , Right > > :: Selection > { }
impl<Join, On>
::diesel::SelectableExpression<::diesel::query_source::joins::JoinOn<Join, On>>
for visit_count
where
visit_count: ::diesel::SelectableExpression<Join>
+ ::diesel::AppearsOnTable<::diesel::query_source::joins::JoinOn<Join, On>>,
{
}
impl<From> ::diesel::SelectableExpression<::diesel::query_builder::SelectStatement<From>>
for visit_count
where
visit_count: ::diesel::SelectableExpression<From>
+ ::diesel::AppearsOnTable<::diesel::query_builder::SelectStatement<From>>,
{
}
impl<__GB> ::diesel::expression::ValidGrouping<__GB> for visit_count
where
__GB: ::diesel::expression::IsContainedInGroupBy<
visit_count,
Output = ::diesel::expression::is_contained_in_group_by::Yes,
>,
{
type IsAggregate = ::diesel::expression::is_aggregate::Yes;
}
impl ::diesel::expression::ValidGrouping<()> for visit_count {
type IsAggregate = ::diesel::expression::is_aggregate::No;
}
impl ::diesel::expression::IsContainedInGroupBy<visit_count> for visit_count {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::query_source::Column for visit_count {
type Table = table;
const NAME: &'static str = "visit_count";
}
impl<T> ::diesel::EqAll<T> for visit_count
where
T: ::diesel::expression::AsExpression<Integer>,
::diesel::dsl::Eq<visit_count, T::Expression>:
::diesel::Expression<SqlType = ::diesel::sql_types::Bool>,
{
type Output = ::diesel::dsl::Eq<Self, T::Expression>;
fn eq_all(self, rhs: T) -> Self::Output {
use ::diesel::expression_methods::ExpressionMethods;
self.eq(rhs)
}
}
impl < Rhs > :: std :: ops :: Add < Rhs > for visit_count where Rhs : :: diesel :: expression :: AsExpression < < < visit_count as :: diesel :: Expression > :: SqlType as :: diesel :: sql_types :: ops :: Add > :: Rhs > { type Output = :: diesel :: expression :: ops :: Add < Self , Rhs :: Expression > ; fn add ( self , rhs : Rhs ) -> Self :: Output { :: diesel :: expression :: ops :: Add :: new ( self , rhs . as_expression ( ) ) } }
impl < Rhs > :: std :: ops :: Sub < Rhs > for visit_count where Rhs : :: diesel :: expression :: AsExpression < < < visit_count as :: diesel :: Expression > :: SqlType as :: diesel :: sql_types :: ops :: Sub > :: Rhs > { type Output = :: diesel :: expression :: ops :: Sub < Self , Rhs :: Expression > ; fn sub ( self , rhs : Rhs ) -> Self :: Output { :: diesel :: expression :: ops :: Sub :: new ( self , rhs . as_expression ( ) ) } }
impl < Rhs > :: std :: ops :: Div < Rhs > for visit_count where Rhs : :: diesel :: expression :: AsExpression < < < visit_count as :: diesel :: Expression > :: SqlType as :: diesel :: sql_types :: ops :: Div > :: Rhs > { type Output = :: diesel :: expression :: ops :: Div < Self , Rhs :: Expression > ; fn div ( self , rhs : Rhs ) -> Self :: Output { :: diesel :: expression :: ops :: Div :: new ( self , rhs . as_expression ( ) ) } }
impl < Rhs > :: std :: ops :: Mul < Rhs > for visit_count where Rhs : :: diesel :: expression :: AsExpression < < < visit_count as :: diesel :: Expression > :: SqlType as :: diesel :: sql_types :: ops :: Mul > :: Rhs > { type Output = :: diesel :: expression :: ops :: Mul < Self , Rhs :: Expression > ; fn mul ( self , rhs : Rhs ) -> Self :: Output { :: diesel :: expression :: ops :: Mul :: new ( self , rhs . as_expression ( ) ) } }
impl ::diesel::expression::IsContainedInGroupBy<title> for id {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::expression::IsContainedInGroupBy<id> for title {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<body> for id {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::expression::IsContainedInGroupBy<id> for body {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<draft> for id {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::expression::IsContainedInGroupBy<id> for draft {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<publish_at> for id {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::expression::IsContainedInGroupBy<id> for publish_at {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<visit_count> for id {
type Output = ::diesel::expression::is_contained_in_group_by::Yes;
}
impl ::diesel::expression::IsContainedInGroupBy<id> for visit_count {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<body> for title {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<title> for body {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<draft> for title {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<title> for draft {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<publish_at> for title {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<title> for publish_at {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<visit_count> for title {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<title> for visit_count {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<draft> for body {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<body> for draft {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<publish_at> for body {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<body> for publish_at {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<visit_count> for body {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<body> for visit_count {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<publish_at> for draft {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<draft> for publish_at {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<visit_count> for draft {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<draft> for visit_count {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<visit_count> for publish_at {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
impl ::diesel::expression::IsContainedInGroupBy<publish_at> for visit_count {
type Output = ::diesel::expression::is_contained_in_group_by::No;
}
}
}
pub struct Post {
pub id: i64,
pub title: String,
pub body: String,
pub draft: bool,
pub publish_at: SystemTime,
pub visit_count: i32,
}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::deserialize::{self, FromStaticSqlRow, Queryable};
use diesel::row::{Row, Field};
use std::convert::TryInto;
impl<__DB: diesel::backend::Backend, __ST0, __ST1, __ST2, __ST3, __ST4, __ST5>
Queryable<(__ST0, __ST1, __ST2, __ST3, __ST4, __ST5), __DB> for Post
where
(i64, String, String, bool, SystemTime, i32):
FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3, __ST4, __ST5), __DB>,
{
type Row = (i64, String, String, bool, SystemTime, i32);
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(Self {
id: (row.0.try_into()?),
title: (row.1.try_into()?),
body: (row.2.try_into()?),
draft: (row.3.try_into()?),
publish_at: (row.4.try_into()?),
visit_count: (row.5.try_into()?),
})
}
}
};
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::associations::{HasTable, Identifiable};
impl HasTable for Post {
type Table = posts::table;
fn table() -> Self::Table {
posts::table
}
}
impl<'ident> Identifiable for &'ident Post {
type Id = (&'ident i64);
fn id(self) -> Self::Id {
(&self.id)
}
}
};
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::AsChangeset;
use diesel::prelude::*;
impl<'update> AsChangeset for &'update Post {
type Target = posts::table;
type Changeset = <(
diesel::dsl::Eq<posts::title, &'update String>,
diesel::dsl::Eq<posts::body, &'update String>,
diesel::dsl::Eq<posts::draft, &'update bool>,
diesel::dsl::Eq<posts::publish_at, &'update SystemTime>,
diesel::dsl::Eq<posts::visit_count, &'update i32>,
) as AsChangeset>::Changeset;
fn as_changeset(self) -> Self::Changeset {
(
posts::title.eq(&self.title),
posts::body.eq(&self.body),
posts::draft.eq(&self.draft),
posts::publish_at.eq(&self.publish_at),
posts::visit_count.eq(&self.visit_count),
)
.as_changeset()
}
}
impl<'update> AsChangeset for Post {
type Target = posts::table;
type Changeset = <(
diesel::dsl::Eq<posts::title, String>,
diesel::dsl::Eq<posts::body, String>,
diesel::dsl::Eq<posts::draft, bool>,
diesel::dsl::Eq<posts::publish_at, SystemTime>,
diesel::dsl::Eq<posts::visit_count, i32>,
) as AsChangeset>::Changeset;
fn as_changeset(self) -> Self::Changeset {
(
posts::title.eq(self.title),
posts::body.eq(self.body),
posts::draft.eq(self.draft),
posts::publish_at.eq(self.publish_at),
posts::visit_count.eq(self.visit_count),
)
.as_changeset()
}
}
};
pub fn publish_all_posts(conn: &PgConnection) -> QueryResult<usize> {
use crate::posts::dsl::*;
diesel::update(posts).set(draft.eq(false)).execute(conn)
}
pub fn publish_pending_posts(conn: &PgConnection) -> QueryResult<usize> {
use crate::posts::dsl::*;
use diesel::dsl::now;
diesel::update(posts)
.filter(publish_at.lt(now))
.set(draft.eq(false))
.execute(conn)
}
pub fn publish_post(post: &Post, conn: &PgConnection) -> QueryResult<usize> {
diesel::update(post)
.set(posts::draft.eq(false))
.execute(conn)
}
pub fn increment_visit_counts(conn: &PgConnection) -> QueryResult<usize> {
use crate::posts::dsl::*;
diesel::update(posts)
.set(visit_count.eq(visit_count + 1))
.execute(conn)
}
pub fn hide_everything(conn: &PgConnection) -> QueryResult<usize> {
use crate::posts::dsl::*;
diesel::update(posts)
.set((
title.eq("[REDACTED]"),
body.eq("This post has been classified"),
))
.execute(conn)
}
pub fn update_from_post_fields(post: &Post, conn: &PgConnection) -> QueryResult<usize> {
diesel::update(posts::table).set(post).execute(conn)
}
pub fn update_with_option(conn: &PgConnection) -> QueryResult<usize> {
#[table_name = "posts"]
struct PostForm<'a> {
title: Option<&'a str>,
body: Option<&'a str>,
}
#[allow(unused_imports)]
const _: () = {
use diesel;
use diesel::query_builder::AsChangeset;
use diesel::prelude::*;
impl<'a, 'update> AsChangeset for &'update PostForm<'a> {
type Target = posts::table;
type Changeset = <(
std::option::Option<diesel::dsl::Eq<posts::title, &'update &'a str>>,
std::option::Option<diesel::dsl::Eq<posts::body, &'update &'a str>>,
) as AsChangeset>::Changeset;
fn as_changeset(self) -> Self::Changeset {
(
self.title.as_ref().map(|x| posts::title.eq(x)),
self.body.as_ref().map(|x| posts::body.eq(x)),
)
.as_changeset()
}
}
impl<'a, 'update> AsChangeset for PostForm<'a> {
type Target = posts::table;
type Changeset = <(
std::option::Option<diesel::dsl::Eq<posts::title, &'a str>>,
std::option::Option<diesel::dsl::Eq<posts::body, &'a str>>,
) as AsChangeset>::Changeset;
fn as_changeset(self) -> Self::Changeset {
(
self.title.map(|x| posts::title.eq(x)),
self.body.map(|x| posts::body.eq(x)),
)
.as_changeset()
}
}
};
diesel::update(posts::table)
.set(&PostForm {
title: None,
body: Some("My new post"),
})
.execute(conn)
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment