tirocinio-canali-steffo-acrate/expansion.rs

#![feature(prelude_import)]
//! Database schema, migrations, and high level database-reliant structures for the [`acrate`] project.
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
/// Database schema information automatically generated by [`diesel`].
///
/// Configured by `diesel.toml`.
mod schema {
    #[allow(unused_imports, dead_code, unreachable_pub, unused_qualifications)]
    pub mod meta_aliases {
        use ::diesel;
        pub use self::columns::*;
        use diesel::sql_types::*;
        /// 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::document;
            pub use super::columns::pattern;
            pub use super::columns::alias;
            pub use super::table as meta_aliases;
        }
        #[allow(non_upper_case_globals, dead_code)]
        /// A tuple of all of the columns on this table
        pub const all_columns: (id, document, pattern, alias) = (
            id,
            document,
            pattern,
            alias,
        );
        #[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(non_camel_case_types)]
        impl ::core::fmt::Debug for table {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "table")
            }
        }
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::clone::Clone for table {
            #[inline]
            fn clone(&self) -> table {
                *self
            }
        }
        #[automatically_derived]
        #[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;
            }
        };
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::default::Default for table {
            #[inline]
            fn default() -> table {
                table {}
            }
        }
        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 = (Uuid, Bpchar, Bpchar, Bpchar);
        /// Helper type for representing a boxed query from this table
        pub type BoxedQuery<'a, DB, ST = SqlType> = diesel::internal::table_macro::BoxedSelectStatement<
            'a,
            ST,
            diesel::internal::table_macro::FromClause<table>,
            DB,
        >;
        impl diesel::QuerySource for table {
            type FromClause = diesel::internal::table_macro::StaticQueryFragmentInstance<
                table,
            >;
            type DefaultSelection = <Self as diesel::Table>::AllColumns;
            fn from_clause(&self) -> Self::FromClause {
                diesel::internal::table_macro::StaticQueryFragmentInstance::new()
            }
            fn default_selection(&self) -> Self::DefaultSelection {
                use diesel::Table;
                Self::all_columns()
            }
        }
        impl<DB> diesel::query_builder::QueryFragment<DB> for table
        where
            DB: diesel::backend::Backend,
            <table as diesel::internal::table_macro::StaticQueryFragment>::Component: diesel::query_builder::QueryFragment<
                DB,
            >,
        {
            fn walk_ast<'b>(
                &'b self,
                __diesel_internal_pass: diesel::query_builder::AstPass<'_, 'b, DB>,
            ) -> diesel::result::QueryResult<()> {
                <table as diesel::internal::table_macro::StaticQueryFragment>::STATIC_COMPONENT
                    .walk_ast(__diesel_internal_pass)
            }
        }
        impl diesel::internal::table_macro::StaticQueryFragment for table {
            type Component = diesel::internal::table_macro::Identifier<'static>;
            const STATIC_COMPONENT: &'static Self::Component = &diesel::internal::table_macro::Identifier(
                "meta_aliases",
            );
        }
        impl diesel::query_builder::AsQuery for table {
            type SqlType = SqlType;
            type Query = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<Self>,
            >;
            fn as_query(self) -> Self::Query {
                diesel::internal::table_macro::SelectStatement::simple(self)
            }
        }
        impl diesel::Table for table {
            type PrimaryKey = id;
            type AllColumns = (id, document, pattern, alias);
            fn primary_key(&self) -> Self::PrimaryKey {
                id
            }
            fn all_columns() -> Self::AllColumns {
                (id, document, pattern, alias)
            }
        }
        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;
                let q: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<table>,
                > = self.as_query();
                q.into_update_target()
            }
        }
        impl diesel::query_source::AppearsInFromClause<table> for table {
            type Count = diesel::query_source::Once;
        }
        impl<S> diesel::internal::table_macro::AliasAppearsInFromClause<S, table>
        for table
        where
            S: diesel::query_source::AliasSource<Target = table>,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S1,
            S2,
        > diesel::internal::table_macro::AliasAliasAppearsInFromClause<table, S2, S1>
        for table
        where
            S1: diesel::query_source::AliasSource<Target = table>,
            S2: diesel::query_source::AliasSource<Target = table>,
            S1: diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >,
        {
            type Count = <S1 as diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >>::Count;
        }
        impl<S> diesel::query_source::AppearsInFromClause<diesel::query_source::Alias<S>>
        for table
        where
            S: diesel::query_source::AliasSource,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S,
            C,
        > diesel::internal::table_macro::FieldAliasMapperAssociatedTypesDisjointnessTrick<
            table,
            S,
            C,
        > for table
        where
            S: diesel::query_source::AliasSource<Target = table> + ::std::clone::Clone,
            C: diesel::query_source::Column<Table = table>,
        {
            type Out = diesel::query_source::AliasedField<S, C>;
            fn map(
                __diesel_internal_column: C,
                __diesel_internal_alias: &diesel::query_source::Alias<S>,
            ) -> Self::Out {
                __diesel_internal_alias.field(__diesel_internal_column)
            }
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::internal::table_macro::NoFromClause {
            type Count = diesel::query_source::Never;
        }
        impl<
            Left,
            Right,
            Kind,
        > diesel::JoinTo<diesel::internal::table_macro::Join<Left, Right, Kind>>
        for table
        where
            diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            >: diesel::JoinTo<table>,
            Left: diesel::query_source::QuerySource,
            Right: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::Join<Left, Right, Kind>;
            type OnClause = <diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    Kind,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::Join::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<Join, On> diesel::JoinTo<diesel::internal::table_macro::JoinOn<Join, On>>
        for table
        where
            diesel::internal::table_macro::JoinOn<Join, On>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::internal::table_macro::JoinOn<Join, On>;
            type OnClause = <diesel::internal::table_macro::JoinOn<
                Join,
                On,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::JoinOn<Join, On>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::JoinOn::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            F,
            S,
            D,
            W,
            O,
            L,
            Of,
            G,
        > diesel::JoinTo<
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >,
        > for table
        where
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >: diesel::JoinTo<table>,
            F: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >;
            type OnClause = <diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<F>,
                    S,
                    D,
                    W,
                    O,
                    L,
                    Of,
                    G,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::SelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            'a,
            QS,
            ST,
            DB,
        > diesel::JoinTo<
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >,
        > for table
        where
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >: diesel::JoinTo<table>,
            QS: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >;
            type OnClause = <diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::BoxedSelectStatement<
                    'a,
                    diesel::internal::table_macro::FromClause<QS>,
                    ST,
                    DB,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::BoxedSelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<S> diesel::JoinTo<diesel::query_source::Alias<S>> for table
        where
            diesel::query_source::Alias<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_source::Alias<S>;
            type OnClause = <diesel::query_source::Alias<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_source::Alias<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_source::Alias::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_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()
            }
        }
        impl<S> diesel::JoinTo<diesel::query_builder::Only<S>> for table
        where
            diesel::query_builder::Only<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_builder::Only<S>;
            type OnClause = <diesel::query_builder::Only<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Only<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Only::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Only<table>,
        > for table {
            type Count = diesel::query_source::Once;
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Only<table> {
            type Count = diesel::query_source::Once;
        }
        impl<S, TSM> diesel::JoinTo<diesel::query_builder::Tablesample<S, TSM>> for table
        where
            diesel::query_builder::Tablesample<S, TSM>: diesel::JoinTo<table>,
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type FromClause = diesel::query_builder::Tablesample<S, TSM>;
            type OnClause = <diesel::query_builder::Tablesample<
                S,
                TSM,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Tablesample<S, TSM>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Tablesample::<
                    S,
                    TSM,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            TSM,
        > diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Tablesample<table, TSM>,
        > for table
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        impl<TSM> diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Tablesample<table, TSM>
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        /// Contains all of the columns of this table
        pub mod columns {
            use ::diesel;
            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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for star {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "star")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for star {
                #[inline]
                fn clone(&self) -> star {
                    *self
                }
            }
            #[automatically_derived]
            #[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, document, pattern, alias): diesel::expression::ValidGrouping<__GB>,
            {
                type IsAggregate = <(
                    id,
                    document,
                    pattern,
                    alias,
                ) 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<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    use diesel::QuerySource;
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for id {
                #[inline]
                fn clone(&self) -> id {
                    *self
                }
            }
            #[automatically_derived]
            #[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(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 = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("id")
                }
            }
            impl diesel::SelectableExpression<super::table> for id {}
            impl<QS> diesel::AppearsOnTable<QS> for id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for id
            where
                id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for id
            where
                From: diesel::query_source::QuerySource,
                id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<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 = super::table;
                const NAME: &'static str = "id";
            }
            impl<T> diesel::EqAll<T> for id
            where
                T: diesel::expression::AsExpression<Uuid>,
                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, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct document;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for document {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "document")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for document {
                #[inline]
                fn clone(&self) -> document {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for document {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for document {
                    type QueryId = document;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for document {
                #[inline]
                fn default() -> document {
                    document {}
                }
            }
            impl diesel::expression::Expression for document {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for document
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("document")
                }
            }
            impl diesel::SelectableExpression<super::table> for document {}
            impl<QS> diesel::AppearsOnTable<QS> for document
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for document
            where
                document: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for document
            where
                From: diesel::query_source::QuerySource,
                document: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for document
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    document,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for document {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for document {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for document {
                type Table = super::table;
                const NAME: &'static str = "document";
            }
            impl<T> diesel::EqAll<T> for document
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    document,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for document {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for document {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct pattern;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for pattern {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "pattern")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for pattern {
                #[inline]
                fn clone(&self) -> pattern {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for pattern {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for pattern {
                    type QueryId = pattern;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for pattern {
                #[inline]
                fn default() -> pattern {
                    pattern {}
                }
            }
            impl diesel::expression::Expression for pattern {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for pattern
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("pattern")
                }
            }
            impl diesel::SelectableExpression<super::table> for pattern {}
            impl<QS> diesel::AppearsOnTable<QS> for pattern
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for pattern
            where
                pattern: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for pattern
            where
                From: diesel::query_source::QuerySource,
                pattern: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for pattern
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    pattern,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for pattern {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for pattern {
                type Table = super::table;
                const NAME: &'static str = "pattern";
            }
            impl<T> diesel::EqAll<T> for pattern
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    pattern,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for pattern {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for pattern {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct alias;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for alias {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "alias")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for alias {
                #[inline]
                fn clone(&self) -> alias {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for alias {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for alias {
                    type QueryId = alias;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for alias {
                #[inline]
                fn default() -> alias {
                    alias {}
                }
            }
            impl diesel::expression::Expression for alias {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for alias
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("alias")
                }
            }
            impl diesel::SelectableExpression<super::table> for alias {}
            impl<QS> diesel::AppearsOnTable<QS> for alias
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for alias
            where
                alias: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for alias
            where
                alias: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for alias
            where
                alias: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for alias
            where
                From: diesel::query_source::QuerySource,
                alias: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for alias
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    alias,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for alias {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<alias> for alias {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for alias {
                type Table = super::table;
                const NAME: &'static str = "alias";
            }
            impl<T> diesel::EqAll<T> for alias
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    alias,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for alias {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for alias {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for alias
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for alias
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            impl diesel::expression::IsContainedInGroupBy<id> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for alias {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<alias> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for alias {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<alias> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for alias {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<alias> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
        }
    }
    #[allow(unused_imports, dead_code, unreachable_pub, unused_qualifications)]
    pub mod meta_link_properties {
        use ::diesel;
        pub use self::columns::*;
        use diesel::sql_types::*;
        /// 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::meta_link_id;
            pub use super::columns::rel;
            pub use super::columns::value;
            pub use super::table as meta_link_properties;
        }
        #[allow(non_upper_case_globals, dead_code)]
        /// A tuple of all of the columns on this table
        pub const all_columns: (id, meta_link_id, rel, value) = (
            id,
            meta_link_id,
            rel,
            value,
        );
        #[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(non_camel_case_types)]
        impl ::core::fmt::Debug for table {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "table")
            }
        }
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::clone::Clone for table {
            #[inline]
            fn clone(&self) -> table {
                *self
            }
        }
        #[automatically_derived]
        #[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;
            }
        };
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::default::Default for table {
            #[inline]
            fn default() -> table {
                table {}
            }
        }
        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 = (Uuid, Uuid, Bpchar, Nullable<Bpchar>);
        /// Helper type for representing a boxed query from this table
        pub type BoxedQuery<'a, DB, ST = SqlType> = diesel::internal::table_macro::BoxedSelectStatement<
            'a,
            ST,
            diesel::internal::table_macro::FromClause<table>,
            DB,
        >;
        impl diesel::QuerySource for table {
            type FromClause = diesel::internal::table_macro::StaticQueryFragmentInstance<
                table,
            >;
            type DefaultSelection = <Self as diesel::Table>::AllColumns;
            fn from_clause(&self) -> Self::FromClause {
                diesel::internal::table_macro::StaticQueryFragmentInstance::new()
            }
            fn default_selection(&self) -> Self::DefaultSelection {
                use diesel::Table;
                Self::all_columns()
            }
        }
        impl<DB> diesel::query_builder::QueryFragment<DB> for table
        where
            DB: diesel::backend::Backend,
            <table as diesel::internal::table_macro::StaticQueryFragment>::Component: diesel::query_builder::QueryFragment<
                DB,
            >,
        {
            fn walk_ast<'b>(
                &'b self,
                __diesel_internal_pass: diesel::query_builder::AstPass<'_, 'b, DB>,
            ) -> diesel::result::QueryResult<()> {
                <table as diesel::internal::table_macro::StaticQueryFragment>::STATIC_COMPONENT
                    .walk_ast(__diesel_internal_pass)
            }
        }
        impl diesel::internal::table_macro::StaticQueryFragment for table {
            type Component = diesel::internal::table_macro::Identifier<'static>;
            const STATIC_COMPONENT: &'static Self::Component = &diesel::internal::table_macro::Identifier(
                "meta_link_properties",
            );
        }
        impl diesel::query_builder::AsQuery for table {
            type SqlType = SqlType;
            type Query = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<Self>,
            >;
            fn as_query(self) -> Self::Query {
                diesel::internal::table_macro::SelectStatement::simple(self)
            }
        }
        impl diesel::Table for table {
            type PrimaryKey = id;
            type AllColumns = (id, meta_link_id, rel, value);
            fn primary_key(&self) -> Self::PrimaryKey {
                id
            }
            fn all_columns() -> Self::AllColumns {
                (id, meta_link_id, rel, value)
            }
        }
        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;
                let q: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<table>,
                > = self.as_query();
                q.into_update_target()
            }
        }
        impl diesel::query_source::AppearsInFromClause<table> for table {
            type Count = diesel::query_source::Once;
        }
        impl<S> diesel::internal::table_macro::AliasAppearsInFromClause<S, table>
        for table
        where
            S: diesel::query_source::AliasSource<Target = table>,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S1,
            S2,
        > diesel::internal::table_macro::AliasAliasAppearsInFromClause<table, S2, S1>
        for table
        where
            S1: diesel::query_source::AliasSource<Target = table>,
            S2: diesel::query_source::AliasSource<Target = table>,
            S1: diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >,
        {
            type Count = <S1 as diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >>::Count;
        }
        impl<S> diesel::query_source::AppearsInFromClause<diesel::query_source::Alias<S>>
        for table
        where
            S: diesel::query_source::AliasSource,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S,
            C,
        > diesel::internal::table_macro::FieldAliasMapperAssociatedTypesDisjointnessTrick<
            table,
            S,
            C,
        > for table
        where
            S: diesel::query_source::AliasSource<Target = table> + ::std::clone::Clone,
            C: diesel::query_source::Column<Table = table>,
        {
            type Out = diesel::query_source::AliasedField<S, C>;
            fn map(
                __diesel_internal_column: C,
                __diesel_internal_alias: &diesel::query_source::Alias<S>,
            ) -> Self::Out {
                __diesel_internal_alias.field(__diesel_internal_column)
            }
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::internal::table_macro::NoFromClause {
            type Count = diesel::query_source::Never;
        }
        impl<
            Left,
            Right,
            Kind,
        > diesel::JoinTo<diesel::internal::table_macro::Join<Left, Right, Kind>>
        for table
        where
            diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            >: diesel::JoinTo<table>,
            Left: diesel::query_source::QuerySource,
            Right: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::Join<Left, Right, Kind>;
            type OnClause = <diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    Kind,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::Join::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<Join, On> diesel::JoinTo<diesel::internal::table_macro::JoinOn<Join, On>>
        for table
        where
            diesel::internal::table_macro::JoinOn<Join, On>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::internal::table_macro::JoinOn<Join, On>;
            type OnClause = <diesel::internal::table_macro::JoinOn<
                Join,
                On,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::JoinOn<Join, On>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::JoinOn::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            F,
            S,
            D,
            W,
            O,
            L,
            Of,
            G,
        > diesel::JoinTo<
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >,
        > for table
        where
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >: diesel::JoinTo<table>,
            F: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >;
            type OnClause = <diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<F>,
                    S,
                    D,
                    W,
                    O,
                    L,
                    Of,
                    G,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::SelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            'a,
            QS,
            ST,
            DB,
        > diesel::JoinTo<
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >,
        > for table
        where
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >: diesel::JoinTo<table>,
            QS: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >;
            type OnClause = <diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::BoxedSelectStatement<
                    'a,
                    diesel::internal::table_macro::FromClause<QS>,
                    ST,
                    DB,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::BoxedSelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<S> diesel::JoinTo<diesel::query_source::Alias<S>> for table
        where
            diesel::query_source::Alias<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_source::Alias<S>;
            type OnClause = <diesel::query_source::Alias<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_source::Alias<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_source::Alias::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_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()
            }
        }
        impl<S> diesel::JoinTo<diesel::query_builder::Only<S>> for table
        where
            diesel::query_builder::Only<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_builder::Only<S>;
            type OnClause = <diesel::query_builder::Only<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Only<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Only::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Only<table>,
        > for table {
            type Count = diesel::query_source::Once;
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Only<table> {
            type Count = diesel::query_source::Once;
        }
        impl<S, TSM> diesel::JoinTo<diesel::query_builder::Tablesample<S, TSM>> for table
        where
            diesel::query_builder::Tablesample<S, TSM>: diesel::JoinTo<table>,
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type FromClause = diesel::query_builder::Tablesample<S, TSM>;
            type OnClause = <diesel::query_builder::Tablesample<
                S,
                TSM,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Tablesample<S, TSM>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Tablesample::<
                    S,
                    TSM,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            TSM,
        > diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Tablesample<table, TSM>,
        > for table
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        impl<TSM> diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Tablesample<table, TSM>
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        /// Contains all of the columns of this table
        pub mod columns {
            use ::diesel;
            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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for star {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "star")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for star {
                #[inline]
                fn clone(&self) -> star {
                    *self
                }
            }
            #[automatically_derived]
            #[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, meta_link_id, rel, value): diesel::expression::ValidGrouping<__GB>,
            {
                type IsAggregate = <(
                    id,
                    meta_link_id,
                    rel,
                    value,
                ) 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<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    use diesel::QuerySource;
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for id {
                #[inline]
                fn clone(&self) -> id {
                    *self
                }
            }
            #[automatically_derived]
            #[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(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 = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("id")
                }
            }
            impl diesel::SelectableExpression<super::table> for id {}
            impl<QS> diesel::AppearsOnTable<QS> for id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for id
            where
                id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for id
            where
                From: diesel::query_source::QuerySource,
                id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<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 = super::table;
                const NAME: &'static str = "id";
            }
            impl<T> diesel::EqAll<T> for id
            where
                T: diesel::expression::AsExpression<Uuid>,
                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, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct meta_link_id;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for meta_link_id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "meta_link_id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for meta_link_id {
                #[inline]
                fn clone(&self) -> meta_link_id {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for meta_link_id {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for meta_link_id {
                    type QueryId = meta_link_id;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for meta_link_id {
                #[inline]
                fn default() -> meta_link_id {
                    meta_link_id {}
                }
            }
            impl diesel::expression::Expression for meta_link_id {
                type SqlType = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for meta_link_id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("meta_link_id")
                }
            }
            impl diesel::SelectableExpression<super::table> for meta_link_id {}
            impl<QS> diesel::AppearsOnTable<QS> for meta_link_id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for meta_link_id
            where
                meta_link_id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for meta_link_id
            where
                meta_link_id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for meta_link_id
            where
                meta_link_id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for meta_link_id
            where
                From: diesel::query_source::QuerySource,
                meta_link_id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for meta_link_id
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    meta_link_id,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for meta_link_id {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id>
            for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for meta_link_id {
                type Table = super::table;
                const NAME: &'static str = "meta_link_id";
            }
            impl<T> diesel::EqAll<T> for meta_link_id
            where
                T: diesel::expression::AsExpression<Uuid>,
                diesel::dsl::Eq<
                    meta_link_id,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for meta_link_id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for meta_link_id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for meta_link_id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for meta_link_id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct rel;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for rel {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "rel")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for rel {
                #[inline]
                fn clone(&self) -> rel {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for rel {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for rel {
                    type QueryId = rel;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for rel {
                #[inline]
                fn default() -> rel {
                    rel {}
                }
            }
            impl diesel::expression::Expression for rel {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for rel
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("rel")
                }
            }
            impl diesel::SelectableExpression<super::table> for rel {}
            impl<QS> diesel::AppearsOnTable<QS> for rel
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for rel
            where
                rel: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for rel
            where
                rel: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for rel
            where
                rel: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for rel
            where
                From: diesel::query_source::QuerySource,
                rel: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for rel
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    rel,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for rel {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for rel {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for rel {
                type Table = super::table;
                const NAME: &'static str = "rel";
            }
            impl<T> diesel::EqAll<T> for rel
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    rel,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for rel {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for rel {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for rel
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for rel
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct value;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for value {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "value")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for value {
                #[inline]
                fn clone(&self) -> value {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for value {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for value {
                    type QueryId = value;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for value {
                #[inline]
                fn default() -> value {
                    value {}
                }
            }
            impl diesel::expression::Expression for value {
                type SqlType = Nullable<Bpchar>;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for value
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("value")
                }
            }
            impl diesel::SelectableExpression<super::table> for value {}
            impl<QS> diesel::AppearsOnTable<QS> for value
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for value
            where
                value: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for value
            where
                value: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for value
            where
                value: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for value
            where
                From: diesel::query_source::QuerySource,
                value: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for value
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    value,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for value {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for value {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for value {
                type Table = super::table;
                const NAME: &'static str = "value";
            }
            impl<T> diesel::EqAll<T> for value
            where
                T: diesel::expression::AsExpression<Nullable<Bpchar>>,
                diesel::dsl::Eq<
                    value,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for value {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for value {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for value
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for value
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            impl diesel::expression::IsContainedInGroupBy<id> for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
        }
    }
    #[allow(unused_imports, dead_code, unreachable_pub, unused_qualifications)]
    pub mod meta_link_titles {
        use ::diesel;
        pub use self::columns::*;
        use diesel::sql_types::*;
        /// 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::meta_link_id;
            pub use super::columns::language;
            pub use super::columns::value;
            pub use super::table as meta_link_titles;
        }
        #[allow(non_upper_case_globals, dead_code)]
        /// A tuple of all of the columns on this table
        pub const all_columns: (id, meta_link_id, language, value) = (
            id,
            meta_link_id,
            language,
            value,
        );
        #[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(non_camel_case_types)]
        impl ::core::fmt::Debug for table {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "table")
            }
        }
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::clone::Clone for table {
            #[inline]
            fn clone(&self) -> table {
                *self
            }
        }
        #[automatically_derived]
        #[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;
            }
        };
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::default::Default for table {
            #[inline]
            fn default() -> table {
                table {}
            }
        }
        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 = (Uuid, Uuid, Bpchar, Bpchar);
        /// Helper type for representing a boxed query from this table
        pub type BoxedQuery<'a, DB, ST = SqlType> = diesel::internal::table_macro::BoxedSelectStatement<
            'a,
            ST,
            diesel::internal::table_macro::FromClause<table>,
            DB,
        >;
        impl diesel::QuerySource for table {
            type FromClause = diesel::internal::table_macro::StaticQueryFragmentInstance<
                table,
            >;
            type DefaultSelection = <Self as diesel::Table>::AllColumns;
            fn from_clause(&self) -> Self::FromClause {
                diesel::internal::table_macro::StaticQueryFragmentInstance::new()
            }
            fn default_selection(&self) -> Self::DefaultSelection {
                use diesel::Table;
                Self::all_columns()
            }
        }
        impl<DB> diesel::query_builder::QueryFragment<DB> for table
        where
            DB: diesel::backend::Backend,
            <table as diesel::internal::table_macro::StaticQueryFragment>::Component: diesel::query_builder::QueryFragment<
                DB,
            >,
        {
            fn walk_ast<'b>(
                &'b self,
                __diesel_internal_pass: diesel::query_builder::AstPass<'_, 'b, DB>,
            ) -> diesel::result::QueryResult<()> {
                <table as diesel::internal::table_macro::StaticQueryFragment>::STATIC_COMPONENT
                    .walk_ast(__diesel_internal_pass)
            }
        }
        impl diesel::internal::table_macro::StaticQueryFragment for table {
            type Component = diesel::internal::table_macro::Identifier<'static>;
            const STATIC_COMPONENT: &'static Self::Component = &diesel::internal::table_macro::Identifier(
                "meta_link_titles",
            );
        }
        impl diesel::query_builder::AsQuery for table {
            type SqlType = SqlType;
            type Query = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<Self>,
            >;
            fn as_query(self) -> Self::Query {
                diesel::internal::table_macro::SelectStatement::simple(self)
            }
        }
        impl diesel::Table for table {
            type PrimaryKey = id;
            type AllColumns = (id, meta_link_id, language, value);
            fn primary_key(&self) -> Self::PrimaryKey {
                id
            }
            fn all_columns() -> Self::AllColumns {
                (id, meta_link_id, language, value)
            }
        }
        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;
                let q: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<table>,
                > = self.as_query();
                q.into_update_target()
            }
        }
        impl diesel::query_source::AppearsInFromClause<table> for table {
            type Count = diesel::query_source::Once;
        }
        impl<S> diesel::internal::table_macro::AliasAppearsInFromClause<S, table>
        for table
        where
            S: diesel::query_source::AliasSource<Target = table>,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S1,
            S2,
        > diesel::internal::table_macro::AliasAliasAppearsInFromClause<table, S2, S1>
        for table
        where
            S1: diesel::query_source::AliasSource<Target = table>,
            S2: diesel::query_source::AliasSource<Target = table>,
            S1: diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >,
        {
            type Count = <S1 as diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >>::Count;
        }
        impl<S> diesel::query_source::AppearsInFromClause<diesel::query_source::Alias<S>>
        for table
        where
            S: diesel::query_source::AliasSource,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S,
            C,
        > diesel::internal::table_macro::FieldAliasMapperAssociatedTypesDisjointnessTrick<
            table,
            S,
            C,
        > for table
        where
            S: diesel::query_source::AliasSource<Target = table> + ::std::clone::Clone,
            C: diesel::query_source::Column<Table = table>,
        {
            type Out = diesel::query_source::AliasedField<S, C>;
            fn map(
                __diesel_internal_column: C,
                __diesel_internal_alias: &diesel::query_source::Alias<S>,
            ) -> Self::Out {
                __diesel_internal_alias.field(__diesel_internal_column)
            }
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::internal::table_macro::NoFromClause {
            type Count = diesel::query_source::Never;
        }
        impl<
            Left,
            Right,
            Kind,
        > diesel::JoinTo<diesel::internal::table_macro::Join<Left, Right, Kind>>
        for table
        where
            diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            >: diesel::JoinTo<table>,
            Left: diesel::query_source::QuerySource,
            Right: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::Join<Left, Right, Kind>;
            type OnClause = <diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    Kind,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::Join::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<Join, On> diesel::JoinTo<diesel::internal::table_macro::JoinOn<Join, On>>
        for table
        where
            diesel::internal::table_macro::JoinOn<Join, On>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::internal::table_macro::JoinOn<Join, On>;
            type OnClause = <diesel::internal::table_macro::JoinOn<
                Join,
                On,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::JoinOn<Join, On>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::JoinOn::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            F,
            S,
            D,
            W,
            O,
            L,
            Of,
            G,
        > diesel::JoinTo<
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >,
        > for table
        where
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >: diesel::JoinTo<table>,
            F: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >;
            type OnClause = <diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<F>,
                    S,
                    D,
                    W,
                    O,
                    L,
                    Of,
                    G,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::SelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            'a,
            QS,
            ST,
            DB,
        > diesel::JoinTo<
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >,
        > for table
        where
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >: diesel::JoinTo<table>,
            QS: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >;
            type OnClause = <diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::BoxedSelectStatement<
                    'a,
                    diesel::internal::table_macro::FromClause<QS>,
                    ST,
                    DB,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::BoxedSelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<S> diesel::JoinTo<diesel::query_source::Alias<S>> for table
        where
            diesel::query_source::Alias<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_source::Alias<S>;
            type OnClause = <diesel::query_source::Alias<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_source::Alias<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_source::Alias::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_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()
            }
        }
        impl<S> diesel::JoinTo<diesel::query_builder::Only<S>> for table
        where
            diesel::query_builder::Only<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_builder::Only<S>;
            type OnClause = <diesel::query_builder::Only<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Only<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Only::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Only<table>,
        > for table {
            type Count = diesel::query_source::Once;
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Only<table> {
            type Count = diesel::query_source::Once;
        }
        impl<S, TSM> diesel::JoinTo<diesel::query_builder::Tablesample<S, TSM>> for table
        where
            diesel::query_builder::Tablesample<S, TSM>: diesel::JoinTo<table>,
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type FromClause = diesel::query_builder::Tablesample<S, TSM>;
            type OnClause = <diesel::query_builder::Tablesample<
                S,
                TSM,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Tablesample<S, TSM>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Tablesample::<
                    S,
                    TSM,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            TSM,
        > diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Tablesample<table, TSM>,
        > for table
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        impl<TSM> diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Tablesample<table, TSM>
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        /// Contains all of the columns of this table
        pub mod columns {
            use ::diesel;
            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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for star {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "star")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for star {
                #[inline]
                fn clone(&self) -> star {
                    *self
                }
            }
            #[automatically_derived]
            #[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,
                    meta_link_id,
                    language,
                    value,
                ): diesel::expression::ValidGrouping<__GB>,
            {
                type IsAggregate = <(
                    id,
                    meta_link_id,
                    language,
                    value,
                ) 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<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    use diesel::QuerySource;
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for id {
                #[inline]
                fn clone(&self) -> id {
                    *self
                }
            }
            #[automatically_derived]
            #[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(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 = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("id")
                }
            }
            impl diesel::SelectableExpression<super::table> for id {}
            impl<QS> diesel::AppearsOnTable<QS> for id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for id
            where
                id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for id
            where
                From: diesel::query_source::QuerySource,
                id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<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 = super::table;
                const NAME: &'static str = "id";
            }
            impl<T> diesel::EqAll<T> for id
            where
                T: diesel::expression::AsExpression<Uuid>,
                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, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct meta_link_id;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for meta_link_id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "meta_link_id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for meta_link_id {
                #[inline]
                fn clone(&self) -> meta_link_id {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for meta_link_id {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for meta_link_id {
                    type QueryId = meta_link_id;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for meta_link_id {
                #[inline]
                fn default() -> meta_link_id {
                    meta_link_id {}
                }
            }
            impl diesel::expression::Expression for meta_link_id {
                type SqlType = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for meta_link_id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("meta_link_id")
                }
            }
            impl diesel::SelectableExpression<super::table> for meta_link_id {}
            impl<QS> diesel::AppearsOnTable<QS> for meta_link_id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for meta_link_id
            where
                meta_link_id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for meta_link_id
            where
                meta_link_id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for meta_link_id
            where
                meta_link_id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for meta_link_id
            where
                From: diesel::query_source::QuerySource,
                meta_link_id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for meta_link_id
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    meta_link_id,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for meta_link_id {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id>
            for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for meta_link_id {
                type Table = super::table;
                const NAME: &'static str = "meta_link_id";
            }
            impl<T> diesel::EqAll<T> for meta_link_id
            where
                T: diesel::expression::AsExpression<Uuid>,
                diesel::dsl::Eq<
                    meta_link_id,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for meta_link_id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for meta_link_id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for meta_link_id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for meta_link_id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct language;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for language {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "language")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for language {
                #[inline]
                fn clone(&self) -> language {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for language {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for language {
                    type QueryId = language;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for language {
                #[inline]
                fn default() -> language {
                    language {}
                }
            }
            impl diesel::expression::Expression for language {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for language
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("language")
                }
            }
            impl diesel::SelectableExpression<super::table> for language {}
            impl<QS> diesel::AppearsOnTable<QS> for language
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for language
            where
                language: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for language
            where
                language: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for language
            where
                language: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for language
            where
                From: diesel::query_source::QuerySource,
                language: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for language
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    language,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for language {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<language> for language {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for language {
                type Table = super::table;
                const NAME: &'static str = "language";
            }
            impl<T> diesel::EqAll<T> for language
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    language,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for language {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for language {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for language
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for language
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct value;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for value {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "value")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for value {
                #[inline]
                fn clone(&self) -> value {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for value {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for value {
                    type QueryId = value;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for value {
                #[inline]
                fn default() -> value {
                    value {}
                }
            }
            impl diesel::expression::Expression for value {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for value
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("value")
                }
            }
            impl diesel::SelectableExpression<super::table> for value {}
            impl<QS> diesel::AppearsOnTable<QS> for value
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for value
            where
                value: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for value
            where
                value: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for value
            where
                value: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for value
            where
                From: diesel::query_source::QuerySource,
                value: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for value
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    value,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for value {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for value {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for value {
                type Table = super::table;
                const NAME: &'static str = "value";
            }
            impl<T> diesel::EqAll<T> for value
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    value,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for value {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for value {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for value
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for value
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            impl diesel::expression::IsContainedInGroupBy<id> for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for language {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<language> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id> for language {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<language> for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<meta_link_id> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for meta_link_id {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<language> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for language {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
        }
    }
    #[allow(unused_imports, dead_code, unreachable_pub, unused_qualifications)]
    pub mod meta_links {
        use ::diesel;
        pub use self::columns::*;
        use diesel::sql_types::*;
        /// 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::document;
            pub use super::columns::pattern;
            pub use super::columns::rel;
            pub use super::columns::type_;
            pub use super::columns::href;
            pub use super::columns::template;
            pub use super::table as meta_links;
        }
        #[allow(non_upper_case_globals, dead_code)]
        /// A tuple of all of the columns on this table
        pub const all_columns: (id, document, pattern, rel, type_, href, template) = (
            id,
            document,
            pattern,
            rel,
            type_,
            href,
            template,
        );
        #[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(non_camel_case_types)]
        impl ::core::fmt::Debug for table {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "table")
            }
        }
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::clone::Clone for table {
            #[inline]
            fn clone(&self) -> table {
                *self
            }
        }
        #[automatically_derived]
        #[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;
            }
        };
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::default::Default for table {
            #[inline]
            fn default() -> table {
                table {}
            }
        }
        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 = (
            Uuid,
            Bpchar,
            Bpchar,
            Bpchar,
            Nullable<Bpchar>,
            Nullable<Bpchar>,
            Nullable<Bpchar>,
        );
        /// Helper type for representing a boxed query from this table
        pub type BoxedQuery<'a, DB, ST = SqlType> = diesel::internal::table_macro::BoxedSelectStatement<
            'a,
            ST,
            diesel::internal::table_macro::FromClause<table>,
            DB,
        >;
        impl diesel::QuerySource for table {
            type FromClause = diesel::internal::table_macro::StaticQueryFragmentInstance<
                table,
            >;
            type DefaultSelection = <Self as diesel::Table>::AllColumns;
            fn from_clause(&self) -> Self::FromClause {
                diesel::internal::table_macro::StaticQueryFragmentInstance::new()
            }
            fn default_selection(&self) -> Self::DefaultSelection {
                use diesel::Table;
                Self::all_columns()
            }
        }
        impl<DB> diesel::query_builder::QueryFragment<DB> for table
        where
            DB: diesel::backend::Backend,
            <table as diesel::internal::table_macro::StaticQueryFragment>::Component: diesel::query_builder::QueryFragment<
                DB,
            >,
        {
            fn walk_ast<'b>(
                &'b self,
                __diesel_internal_pass: diesel::query_builder::AstPass<'_, 'b, DB>,
            ) -> diesel::result::QueryResult<()> {
                <table as diesel::internal::table_macro::StaticQueryFragment>::STATIC_COMPONENT
                    .walk_ast(__diesel_internal_pass)
            }
        }
        impl diesel::internal::table_macro::StaticQueryFragment for table {
            type Component = diesel::internal::table_macro::Identifier<'static>;
            const STATIC_COMPONENT: &'static Self::Component = &diesel::internal::table_macro::Identifier(
                "meta_links",
            );
        }
        impl diesel::query_builder::AsQuery for table {
            type SqlType = SqlType;
            type Query = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<Self>,
            >;
            fn as_query(self) -> Self::Query {
                diesel::internal::table_macro::SelectStatement::simple(self)
            }
        }
        impl diesel::Table for table {
            type PrimaryKey = id;
            type AllColumns = (id, document, pattern, rel, type_, href, template);
            fn primary_key(&self) -> Self::PrimaryKey {
                id
            }
            fn all_columns() -> Self::AllColumns {
                (id, document, pattern, rel, type_, href, template)
            }
        }
        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;
                let q: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<table>,
                > = self.as_query();
                q.into_update_target()
            }
        }
        impl diesel::query_source::AppearsInFromClause<table> for table {
            type Count = diesel::query_source::Once;
        }
        impl<S> diesel::internal::table_macro::AliasAppearsInFromClause<S, table>
        for table
        where
            S: diesel::query_source::AliasSource<Target = table>,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S1,
            S2,
        > diesel::internal::table_macro::AliasAliasAppearsInFromClause<table, S2, S1>
        for table
        where
            S1: diesel::query_source::AliasSource<Target = table>,
            S2: diesel::query_source::AliasSource<Target = table>,
            S1: diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >,
        {
            type Count = <S1 as diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >>::Count;
        }
        impl<S> diesel::query_source::AppearsInFromClause<diesel::query_source::Alias<S>>
        for table
        where
            S: diesel::query_source::AliasSource,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S,
            C,
        > diesel::internal::table_macro::FieldAliasMapperAssociatedTypesDisjointnessTrick<
            table,
            S,
            C,
        > for table
        where
            S: diesel::query_source::AliasSource<Target = table> + ::std::clone::Clone,
            C: diesel::query_source::Column<Table = table>,
        {
            type Out = diesel::query_source::AliasedField<S, C>;
            fn map(
                __diesel_internal_column: C,
                __diesel_internal_alias: &diesel::query_source::Alias<S>,
            ) -> Self::Out {
                __diesel_internal_alias.field(__diesel_internal_column)
            }
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::internal::table_macro::NoFromClause {
            type Count = diesel::query_source::Never;
        }
        impl<
            Left,
            Right,
            Kind,
        > diesel::JoinTo<diesel::internal::table_macro::Join<Left, Right, Kind>>
        for table
        where
            diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            >: diesel::JoinTo<table>,
            Left: diesel::query_source::QuerySource,
            Right: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::Join<Left, Right, Kind>;
            type OnClause = <diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    Kind,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::Join::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<Join, On> diesel::JoinTo<diesel::internal::table_macro::JoinOn<Join, On>>
        for table
        where
            diesel::internal::table_macro::JoinOn<Join, On>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::internal::table_macro::JoinOn<Join, On>;
            type OnClause = <diesel::internal::table_macro::JoinOn<
                Join,
                On,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::JoinOn<Join, On>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::JoinOn::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            F,
            S,
            D,
            W,
            O,
            L,
            Of,
            G,
        > diesel::JoinTo<
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >,
        > for table
        where
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >: diesel::JoinTo<table>,
            F: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >;
            type OnClause = <diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<F>,
                    S,
                    D,
                    W,
                    O,
                    L,
                    Of,
                    G,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::SelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            'a,
            QS,
            ST,
            DB,
        > diesel::JoinTo<
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >,
        > for table
        where
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >: diesel::JoinTo<table>,
            QS: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >;
            type OnClause = <diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::BoxedSelectStatement<
                    'a,
                    diesel::internal::table_macro::FromClause<QS>,
                    ST,
                    DB,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::BoxedSelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<S> diesel::JoinTo<diesel::query_source::Alias<S>> for table
        where
            diesel::query_source::Alias<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_source::Alias<S>;
            type OnClause = <diesel::query_source::Alias<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_source::Alias<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_source::Alias::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_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()
            }
        }
        impl<S> diesel::JoinTo<diesel::query_builder::Only<S>> for table
        where
            diesel::query_builder::Only<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_builder::Only<S>;
            type OnClause = <diesel::query_builder::Only<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Only<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Only::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Only<table>,
        > for table {
            type Count = diesel::query_source::Once;
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Only<table> {
            type Count = diesel::query_source::Once;
        }
        impl<S, TSM> diesel::JoinTo<diesel::query_builder::Tablesample<S, TSM>> for table
        where
            diesel::query_builder::Tablesample<S, TSM>: diesel::JoinTo<table>,
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type FromClause = diesel::query_builder::Tablesample<S, TSM>;
            type OnClause = <diesel::query_builder::Tablesample<
                S,
                TSM,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Tablesample<S, TSM>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Tablesample::<
                    S,
                    TSM,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            TSM,
        > diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Tablesample<table, TSM>,
        > for table
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        impl<TSM> diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Tablesample<table, TSM>
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        /// Contains all of the columns of this table
        pub mod columns {
            use ::diesel;
            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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for star {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "star")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for star {
                #[inline]
                fn clone(&self) -> star {
                    *self
                }
            }
            #[automatically_derived]
            #[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,
                    document,
                    pattern,
                    rel,
                    type_,
                    href,
                    template,
                ): diesel::expression::ValidGrouping<__GB>,
            {
                type IsAggregate = <(
                    id,
                    document,
                    pattern,
                    rel,
                    type_,
                    href,
                    template,
                ) 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<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    use diesel::QuerySource;
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for id {
                #[inline]
                fn clone(&self) -> id {
                    *self
                }
            }
            #[automatically_derived]
            #[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(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 = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("id")
                }
            }
            impl diesel::SelectableExpression<super::table> for id {}
            impl<QS> diesel::AppearsOnTable<QS> for id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for id
            where
                id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for id
            where
                From: diesel::query_source::QuerySource,
                id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<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 = super::table;
                const NAME: &'static str = "id";
            }
            impl<T> diesel::EqAll<T> for id
            where
                T: diesel::expression::AsExpression<Uuid>,
                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, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct document;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for document {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "document")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for document {
                #[inline]
                fn clone(&self) -> document {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for document {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for document {
                    type QueryId = document;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for document {
                #[inline]
                fn default() -> document {
                    document {}
                }
            }
            impl diesel::expression::Expression for document {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for document
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("document")
                }
            }
            impl diesel::SelectableExpression<super::table> for document {}
            impl<QS> diesel::AppearsOnTable<QS> for document
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for document
            where
                document: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for document
            where
                From: diesel::query_source::QuerySource,
                document: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for document
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    document,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for document {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for document {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for document {
                type Table = super::table;
                const NAME: &'static str = "document";
            }
            impl<T> diesel::EqAll<T> for document
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    document,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for document {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for document {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct pattern;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for pattern {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "pattern")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for pattern {
                #[inline]
                fn clone(&self) -> pattern {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for pattern {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for pattern {
                    type QueryId = pattern;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for pattern {
                #[inline]
                fn default() -> pattern {
                    pattern {}
                }
            }
            impl diesel::expression::Expression for pattern {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for pattern
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("pattern")
                }
            }
            impl diesel::SelectableExpression<super::table> for pattern {}
            impl<QS> diesel::AppearsOnTable<QS> for pattern
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for pattern
            where
                pattern: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for pattern
            where
                From: diesel::query_source::QuerySource,
                pattern: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for pattern
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    pattern,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for pattern {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for pattern {
                type Table = super::table;
                const NAME: &'static str = "pattern";
            }
            impl<T> diesel::EqAll<T> for pattern
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    pattern,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for pattern {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for pattern {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct rel;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for rel {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "rel")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for rel {
                #[inline]
                fn clone(&self) -> rel {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for rel {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for rel {
                    type QueryId = rel;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for rel {
                #[inline]
                fn default() -> rel {
                    rel {}
                }
            }
            impl diesel::expression::Expression for rel {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for rel
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("rel")
                }
            }
            impl diesel::SelectableExpression<super::table> for rel {}
            impl<QS> diesel::AppearsOnTable<QS> for rel
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for rel
            where
                rel: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for rel
            where
                rel: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for rel
            where
                rel: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for rel
            where
                From: diesel::query_source::QuerySource,
                rel: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for rel
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    rel,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for rel {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for rel {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for rel {
                type Table = super::table;
                const NAME: &'static str = "rel";
            }
            impl<T> diesel::EqAll<T> for rel
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    rel,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for rel {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for rel {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for rel
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for rel
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct type_;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for type_ {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "type_")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for type_ {
                #[inline]
                fn clone(&self) -> type_ {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for type_ {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for type_ {
                    type QueryId = type_;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for type_ {
                #[inline]
                fn default() -> type_ {
                    type_ {}
                }
            }
            impl diesel::expression::Expression for type_ {
                type SqlType = Nullable<Bpchar>;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for type_
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("type")
                }
            }
            impl diesel::SelectableExpression<super::table> for type_ {}
            impl<QS> diesel::AppearsOnTable<QS> for type_
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for type_
            where
                type_: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for type_
            where
                type_: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for type_
            where
                type_: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for type_
            where
                From: diesel::query_source::QuerySource,
                type_: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for type_
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    type_,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for type_ {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<type_> for type_ {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for type_ {
                type Table = super::table;
                const NAME: &'static str = "type";
            }
            impl<T> diesel::EqAll<T> for type_
            where
                T: diesel::expression::AsExpression<Nullable<Bpchar>>,
                diesel::dsl::Eq<
                    type_,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for type_ {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for type_ {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for type_
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for type_
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct href;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for href {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "href")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for href {
                #[inline]
                fn clone(&self) -> href {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for href {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for href {
                    type QueryId = href;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for href {
                #[inline]
                fn default() -> href {
                    href {}
                }
            }
            impl diesel::expression::Expression for href {
                type SqlType = Nullable<Bpchar>;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for href
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("href")
                }
            }
            impl diesel::SelectableExpression<super::table> for href {}
            impl<QS> diesel::AppearsOnTable<QS> for href
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for href
            where
                href: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for href
            where
                href: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for href
            where
                href: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for href
            where
                From: diesel::query_source::QuerySource,
                href: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for href
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    href,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for href {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<href> for href {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for href {
                type Table = super::table;
                const NAME: &'static str = "href";
            }
            impl<T> diesel::EqAll<T> for href
            where
                T: diesel::expression::AsExpression<Nullable<Bpchar>>,
                diesel::dsl::Eq<
                    href,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for href {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for href {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for href
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for href
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct template;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for template {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "template")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for template {
                #[inline]
                fn clone(&self) -> template {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for template {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for template {
                    type QueryId = template;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for template {
                #[inline]
                fn default() -> template {
                    template {}
                }
            }
            impl diesel::expression::Expression for template {
                type SqlType = Nullable<Bpchar>;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for template
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("template")
                }
            }
            impl diesel::SelectableExpression<super::table> for template {}
            impl<QS> diesel::AppearsOnTable<QS> for template
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for template
            where
                template: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for template
            where
                template: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for template
            where
                template: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for template
            where
                From: diesel::query_source::QuerySource,
                template: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for template
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    template,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for template {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<template> for template {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for template {
                type Table = super::table;
                const NAME: &'static str = "template";
            }
            impl<T> diesel::EqAll<T> for template
            where
                T: diesel::expression::AsExpression<Nullable<Bpchar>>,
                diesel::dsl::Eq<
                    template,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for template {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for template {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for template
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for template
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            impl diesel::expression::IsContainedInGroupBy<id> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for type_ {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<type_> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for href {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<href> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for template {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<template> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for type_ {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<type_> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for href {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<href> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for template {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<template> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for type_ {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<type_> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for href {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<href> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for template {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<template> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for type_ {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<type_> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for href {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<href> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for template {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<template> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<type_> for href {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<href> for type_ {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<type_> for template {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<template> for type_ {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<href> for template {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<template> for href {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
        }
    }
    #[allow(unused_imports, dead_code, unreachable_pub, unused_qualifications)]
    pub mod meta_properties {
        use ::diesel;
        pub use self::columns::*;
        use diesel::sql_types::*;
        /// 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::document;
            pub use super::columns::pattern;
            pub use super::columns::rel;
            pub use super::columns::value;
            pub use super::table as meta_properties;
        }
        #[allow(non_upper_case_globals, dead_code)]
        /// A tuple of all of the columns on this table
        pub const all_columns: (id, document, pattern, rel, value) = (
            id,
            document,
            pattern,
            rel,
            value,
        );
        #[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(non_camel_case_types)]
        impl ::core::fmt::Debug for table {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "table")
            }
        }
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::clone::Clone for table {
            #[inline]
            fn clone(&self) -> table {
                *self
            }
        }
        #[automatically_derived]
        #[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;
            }
        };
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::default::Default for table {
            #[inline]
            fn default() -> table {
                table {}
            }
        }
        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 = (Uuid, Bpchar, Bpchar, Bpchar, Nullable<Bpchar>);
        /// Helper type for representing a boxed query from this table
        pub type BoxedQuery<'a, DB, ST = SqlType> = diesel::internal::table_macro::BoxedSelectStatement<
            'a,
            ST,
            diesel::internal::table_macro::FromClause<table>,
            DB,
        >;
        impl diesel::QuerySource for table {
            type FromClause = diesel::internal::table_macro::StaticQueryFragmentInstance<
                table,
            >;
            type DefaultSelection = <Self as diesel::Table>::AllColumns;
            fn from_clause(&self) -> Self::FromClause {
                diesel::internal::table_macro::StaticQueryFragmentInstance::new()
            }
            fn default_selection(&self) -> Self::DefaultSelection {
                use diesel::Table;
                Self::all_columns()
            }
        }
        impl<DB> diesel::query_builder::QueryFragment<DB> for table
        where
            DB: diesel::backend::Backend,
            <table as diesel::internal::table_macro::StaticQueryFragment>::Component: diesel::query_builder::QueryFragment<
                DB,
            >,
        {
            fn walk_ast<'b>(
                &'b self,
                __diesel_internal_pass: diesel::query_builder::AstPass<'_, 'b, DB>,
            ) -> diesel::result::QueryResult<()> {
                <table as diesel::internal::table_macro::StaticQueryFragment>::STATIC_COMPONENT
                    .walk_ast(__diesel_internal_pass)
            }
        }
        impl diesel::internal::table_macro::StaticQueryFragment for table {
            type Component = diesel::internal::table_macro::Identifier<'static>;
            const STATIC_COMPONENT: &'static Self::Component = &diesel::internal::table_macro::Identifier(
                "meta_properties",
            );
        }
        impl diesel::query_builder::AsQuery for table {
            type SqlType = SqlType;
            type Query = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<Self>,
            >;
            fn as_query(self) -> Self::Query {
                diesel::internal::table_macro::SelectStatement::simple(self)
            }
        }
        impl diesel::Table for table {
            type PrimaryKey = id;
            type AllColumns = (id, document, pattern, rel, value);
            fn primary_key(&self) -> Self::PrimaryKey {
                id
            }
            fn all_columns() -> Self::AllColumns {
                (id, document, pattern, rel, value)
            }
        }
        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;
                let q: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<table>,
                > = self.as_query();
                q.into_update_target()
            }
        }
        impl diesel::query_source::AppearsInFromClause<table> for table {
            type Count = diesel::query_source::Once;
        }
        impl<S> diesel::internal::table_macro::AliasAppearsInFromClause<S, table>
        for table
        where
            S: diesel::query_source::AliasSource<Target = table>,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S1,
            S2,
        > diesel::internal::table_macro::AliasAliasAppearsInFromClause<table, S2, S1>
        for table
        where
            S1: diesel::query_source::AliasSource<Target = table>,
            S2: diesel::query_source::AliasSource<Target = table>,
            S1: diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >,
        {
            type Count = <S1 as diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >>::Count;
        }
        impl<S> diesel::query_source::AppearsInFromClause<diesel::query_source::Alias<S>>
        for table
        where
            S: diesel::query_source::AliasSource,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S,
            C,
        > diesel::internal::table_macro::FieldAliasMapperAssociatedTypesDisjointnessTrick<
            table,
            S,
            C,
        > for table
        where
            S: diesel::query_source::AliasSource<Target = table> + ::std::clone::Clone,
            C: diesel::query_source::Column<Table = table>,
        {
            type Out = diesel::query_source::AliasedField<S, C>;
            fn map(
                __diesel_internal_column: C,
                __diesel_internal_alias: &diesel::query_source::Alias<S>,
            ) -> Self::Out {
                __diesel_internal_alias.field(__diesel_internal_column)
            }
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::internal::table_macro::NoFromClause {
            type Count = diesel::query_source::Never;
        }
        impl<
            Left,
            Right,
            Kind,
        > diesel::JoinTo<diesel::internal::table_macro::Join<Left, Right, Kind>>
        for table
        where
            diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            >: diesel::JoinTo<table>,
            Left: diesel::query_source::QuerySource,
            Right: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::Join<Left, Right, Kind>;
            type OnClause = <diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    Kind,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::Join::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<Join, On> diesel::JoinTo<diesel::internal::table_macro::JoinOn<Join, On>>
        for table
        where
            diesel::internal::table_macro::JoinOn<Join, On>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::internal::table_macro::JoinOn<Join, On>;
            type OnClause = <diesel::internal::table_macro::JoinOn<
                Join,
                On,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::JoinOn<Join, On>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::JoinOn::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            F,
            S,
            D,
            W,
            O,
            L,
            Of,
            G,
        > diesel::JoinTo<
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >,
        > for table
        where
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >: diesel::JoinTo<table>,
            F: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >;
            type OnClause = <diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<F>,
                    S,
                    D,
                    W,
                    O,
                    L,
                    Of,
                    G,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::SelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            'a,
            QS,
            ST,
            DB,
        > diesel::JoinTo<
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >,
        > for table
        where
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >: diesel::JoinTo<table>,
            QS: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >;
            type OnClause = <diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::BoxedSelectStatement<
                    'a,
                    diesel::internal::table_macro::FromClause<QS>,
                    ST,
                    DB,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::BoxedSelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<S> diesel::JoinTo<diesel::query_source::Alias<S>> for table
        where
            diesel::query_source::Alias<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_source::Alias<S>;
            type OnClause = <diesel::query_source::Alias<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_source::Alias<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_source::Alias::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_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()
            }
        }
        impl<S> diesel::JoinTo<diesel::query_builder::Only<S>> for table
        where
            diesel::query_builder::Only<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_builder::Only<S>;
            type OnClause = <diesel::query_builder::Only<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Only<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Only::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Only<table>,
        > for table {
            type Count = diesel::query_source::Once;
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Only<table> {
            type Count = diesel::query_source::Once;
        }
        impl<S, TSM> diesel::JoinTo<diesel::query_builder::Tablesample<S, TSM>> for table
        where
            diesel::query_builder::Tablesample<S, TSM>: diesel::JoinTo<table>,
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type FromClause = diesel::query_builder::Tablesample<S, TSM>;
            type OnClause = <diesel::query_builder::Tablesample<
                S,
                TSM,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Tablesample<S, TSM>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Tablesample::<
                    S,
                    TSM,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            TSM,
        > diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Tablesample<table, TSM>,
        > for table
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        impl<TSM> diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Tablesample<table, TSM>
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        /// Contains all of the columns of this table
        pub mod columns {
            use ::diesel;
            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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for star {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "star")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for star {
                #[inline]
                fn clone(&self) -> star {
                    *self
                }
            }
            #[automatically_derived]
            #[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,
                    document,
                    pattern,
                    rel,
                    value,
                ): diesel::expression::ValidGrouping<__GB>,
            {
                type IsAggregate = <(
                    id,
                    document,
                    pattern,
                    rel,
                    value,
                ) 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<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    use diesel::QuerySource;
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for id {
                #[inline]
                fn clone(&self) -> id {
                    *self
                }
            }
            #[automatically_derived]
            #[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(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 = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("id")
                }
            }
            impl diesel::SelectableExpression<super::table> for id {}
            impl<QS> diesel::AppearsOnTable<QS> for id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for id
            where
                id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for id
            where
                From: diesel::query_source::QuerySource,
                id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<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 = super::table;
                const NAME: &'static str = "id";
            }
            impl<T> diesel::EqAll<T> for id
            where
                T: diesel::expression::AsExpression<Uuid>,
                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, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct document;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for document {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "document")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for document {
                #[inline]
                fn clone(&self) -> document {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for document {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for document {
                    type QueryId = document;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for document {
                #[inline]
                fn default() -> document {
                    document {}
                }
            }
            impl diesel::expression::Expression for document {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for document
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("document")
                }
            }
            impl diesel::SelectableExpression<super::table> for document {}
            impl<QS> diesel::AppearsOnTable<QS> for document
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for document
            where
                document: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for document
            where
                From: diesel::query_source::QuerySource,
                document: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for document
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    document,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for document {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for document {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for document {
                type Table = super::table;
                const NAME: &'static str = "document";
            }
            impl<T> diesel::EqAll<T> for document
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    document,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for document {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for document {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct pattern;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for pattern {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "pattern")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for pattern {
                #[inline]
                fn clone(&self) -> pattern {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for pattern {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for pattern {
                    type QueryId = pattern;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for pattern {
                #[inline]
                fn default() -> pattern {
                    pattern {}
                }
            }
            impl diesel::expression::Expression for pattern {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for pattern
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("pattern")
                }
            }
            impl diesel::SelectableExpression<super::table> for pattern {}
            impl<QS> diesel::AppearsOnTable<QS> for pattern
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for pattern
            where
                pattern: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for pattern
            where
                From: diesel::query_source::QuerySource,
                pattern: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for pattern
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    pattern,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for pattern {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for pattern {
                type Table = super::table;
                const NAME: &'static str = "pattern";
            }
            impl<T> diesel::EqAll<T> for pattern
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    pattern,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for pattern {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for pattern {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct rel;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for rel {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "rel")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for rel {
                #[inline]
                fn clone(&self) -> rel {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for rel {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for rel {
                    type QueryId = rel;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for rel {
                #[inline]
                fn default() -> rel {
                    rel {}
                }
            }
            impl diesel::expression::Expression for rel {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for rel
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("rel")
                }
            }
            impl diesel::SelectableExpression<super::table> for rel {}
            impl<QS> diesel::AppearsOnTable<QS> for rel
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for rel
            where
                rel: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for rel
            where
                rel: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for rel
            where
                rel: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for rel
            where
                From: diesel::query_source::QuerySource,
                rel: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for rel
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    rel,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for rel {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for rel {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for rel {
                type Table = super::table;
                const NAME: &'static str = "rel";
            }
            impl<T> diesel::EqAll<T> for rel
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    rel,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for rel {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for rel {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for rel
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for rel
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct value;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for value {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "value")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for value {
                #[inline]
                fn clone(&self) -> value {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for value {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for value {
                    type QueryId = value;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for value {
                #[inline]
                fn default() -> value {
                    value {}
                }
            }
            impl diesel::expression::Expression for value {
                type SqlType = Nullable<Bpchar>;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for value
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("value")
                }
            }
            impl diesel::SelectableExpression<super::table> for value {}
            impl<QS> diesel::AppearsOnTable<QS> for value
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for value
            where
                value: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for value
            where
                value: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for value
            where
                value: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for value
            where
                From: diesel::query_source::QuerySource,
                value: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for value
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    value,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for value {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for value {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for value {
                type Table = super::table;
                const NAME: &'static str = "value";
            }
            impl<T> diesel::EqAll<T> for value
            where
                T: diesel::expression::AsExpression<Nullable<Bpchar>>,
                diesel::dsl::Eq<
                    value,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for value {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for value {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for value
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for value
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            impl diesel::expression::IsContainedInGroupBy<id> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<rel> for value {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<value> for rel {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
        }
    }
    #[allow(unused_imports, dead_code, unreachable_pub, unused_qualifications)]
    pub mod meta_subjects {
        use ::diesel;
        pub use self::columns::*;
        use diesel::sql_types::*;
        /// 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::document;
            pub use super::columns::pattern;
            pub use super::columns::subject;
            pub use super::columns::redirect;
            pub use super::table as meta_subjects;
        }
        #[allow(non_upper_case_globals, dead_code)]
        /// A tuple of all of the columns on this table
        pub const all_columns: (id, document, pattern, subject, redirect) = (
            id,
            document,
            pattern,
            subject,
            redirect,
        );
        #[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(non_camel_case_types)]
        impl ::core::fmt::Debug for table {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "table")
            }
        }
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::clone::Clone for table {
            #[inline]
            fn clone(&self) -> table {
                *self
            }
        }
        #[automatically_derived]
        #[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;
            }
        };
        #[automatically_derived]
        #[allow(non_camel_case_types)]
        impl ::core::default::Default for table {
            #[inline]
            fn default() -> table {
                table {}
            }
        }
        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 = (Uuid, Bpchar, Bpchar, Nullable<Bpchar>, Nullable<Bpchar>);
        /// Helper type for representing a boxed query from this table
        pub type BoxedQuery<'a, DB, ST = SqlType> = diesel::internal::table_macro::BoxedSelectStatement<
            'a,
            ST,
            diesel::internal::table_macro::FromClause<table>,
            DB,
        >;
        impl diesel::QuerySource for table {
            type FromClause = diesel::internal::table_macro::StaticQueryFragmentInstance<
                table,
            >;
            type DefaultSelection = <Self as diesel::Table>::AllColumns;
            fn from_clause(&self) -> Self::FromClause {
                diesel::internal::table_macro::StaticQueryFragmentInstance::new()
            }
            fn default_selection(&self) -> Self::DefaultSelection {
                use diesel::Table;
                Self::all_columns()
            }
        }
        impl<DB> diesel::query_builder::QueryFragment<DB> for table
        where
            DB: diesel::backend::Backend,
            <table as diesel::internal::table_macro::StaticQueryFragment>::Component: diesel::query_builder::QueryFragment<
                DB,
            >,
        {
            fn walk_ast<'b>(
                &'b self,
                __diesel_internal_pass: diesel::query_builder::AstPass<'_, 'b, DB>,
            ) -> diesel::result::QueryResult<()> {
                <table as diesel::internal::table_macro::StaticQueryFragment>::STATIC_COMPONENT
                    .walk_ast(__diesel_internal_pass)
            }
        }
        impl diesel::internal::table_macro::StaticQueryFragment for table {
            type Component = diesel::internal::table_macro::Identifier<'static>;
            const STATIC_COMPONENT: &'static Self::Component = &diesel::internal::table_macro::Identifier(
                "meta_subjects",
            );
        }
        impl diesel::query_builder::AsQuery for table {
            type SqlType = SqlType;
            type Query = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<Self>,
            >;
            fn as_query(self) -> Self::Query {
                diesel::internal::table_macro::SelectStatement::simple(self)
            }
        }
        impl diesel::Table for table {
            type PrimaryKey = id;
            type AllColumns = (id, document, pattern, subject, redirect);
            fn primary_key(&self) -> Self::PrimaryKey {
                id
            }
            fn all_columns() -> Self::AllColumns {
                (id, document, pattern, subject, redirect)
            }
        }
        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;
                let q: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<table>,
                > = self.as_query();
                q.into_update_target()
            }
        }
        impl diesel::query_source::AppearsInFromClause<table> for table {
            type Count = diesel::query_source::Once;
        }
        impl<S> diesel::internal::table_macro::AliasAppearsInFromClause<S, table>
        for table
        where
            S: diesel::query_source::AliasSource<Target = table>,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S1,
            S2,
        > diesel::internal::table_macro::AliasAliasAppearsInFromClause<table, S2, S1>
        for table
        where
            S1: diesel::query_source::AliasSource<Target = table>,
            S2: diesel::query_source::AliasSource<Target = table>,
            S1: diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >,
        {
            type Count = <S1 as diesel::internal::table_macro::AliasAliasAppearsInFromClauseSameTable<
                S2,
                table,
            >>::Count;
        }
        impl<S> diesel::query_source::AppearsInFromClause<diesel::query_source::Alias<S>>
        for table
        where
            S: diesel::query_source::AliasSource,
        {
            type Count = diesel::query_source::Never;
        }
        impl<
            S,
            C,
        > diesel::internal::table_macro::FieldAliasMapperAssociatedTypesDisjointnessTrick<
            table,
            S,
            C,
        > for table
        where
            S: diesel::query_source::AliasSource<Target = table> + ::std::clone::Clone,
            C: diesel::query_source::Column<Table = table>,
        {
            type Out = diesel::query_source::AliasedField<S, C>;
            fn map(
                __diesel_internal_column: C,
                __diesel_internal_alias: &diesel::query_source::Alias<S>,
            ) -> Self::Out {
                __diesel_internal_alias.field(__diesel_internal_column)
            }
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::internal::table_macro::NoFromClause {
            type Count = diesel::query_source::Never;
        }
        impl<
            Left,
            Right,
            Kind,
        > diesel::JoinTo<diesel::internal::table_macro::Join<Left, Right, Kind>>
        for table
        where
            diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            >: diesel::JoinTo<table>,
            Left: diesel::query_source::QuerySource,
            Right: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::Join<Left, Right, Kind>;
            type OnClause = <diesel::internal::table_macro::Join<
                Left,
                Right,
                Kind,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    Kind,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::Join::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<Join, On> diesel::JoinTo<diesel::internal::table_macro::JoinOn<Join, On>>
        for table
        where
            diesel::internal::table_macro::JoinOn<Join, On>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::internal::table_macro::JoinOn<Join, On>;
            type OnClause = <diesel::internal::table_macro::JoinOn<
                Join,
                On,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::JoinOn<Join, On>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::JoinOn::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            F,
            S,
            D,
            W,
            O,
            L,
            Of,
            G,
        > diesel::JoinTo<
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >,
        > for table
        where
            diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >: diesel::JoinTo<table>,
            F: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            >;
            type OnClause = <diesel::internal::table_macro::SelectStatement<
                diesel::internal::table_macro::FromClause<F>,
                S,
                D,
                W,
                O,
                L,
                Of,
                G,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<F>,
                    S,
                    D,
                    W,
                    O,
                    L,
                    Of,
                    G,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::SelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            'a,
            QS,
            ST,
            DB,
        > diesel::JoinTo<
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >,
        > for table
        where
            diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >: diesel::JoinTo<table>,
            QS: diesel::query_source::QuerySource,
        {
            type FromClause = diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            >;
            type OnClause = <diesel::internal::table_macro::BoxedSelectStatement<
                'a,
                diesel::internal::table_macro::FromClause<QS>,
                ST,
                DB,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::internal::table_macro::BoxedSelectStatement<
                    'a,
                    diesel::internal::table_macro::FromClause<QS>,
                    ST,
                    DB,
                >,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::internal::table_macro::BoxedSelectStatement::join_target(
                    table,
                );
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<S> diesel::JoinTo<diesel::query_source::Alias<S>> for table
        where
            diesel::query_source::Alias<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_source::Alias<S>;
            type OnClause = <diesel::query_source::Alias<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_source::Alias<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_source::Alias::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_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()
            }
        }
        impl<S> diesel::JoinTo<diesel::query_builder::Only<S>> for table
        where
            diesel::query_builder::Only<S>: diesel::JoinTo<table>,
        {
            type FromClause = diesel::query_builder::Only<S>;
            type OnClause = <diesel::query_builder::Only<
                S,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Only<S>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Only::<
                    S,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Only<table>,
        > for table {
            type Count = diesel::query_source::Once;
        }
        impl diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Only<table> {
            type Count = diesel::query_source::Once;
        }
        impl<S, TSM> diesel::JoinTo<diesel::query_builder::Tablesample<S, TSM>> for table
        where
            diesel::query_builder::Tablesample<S, TSM>: diesel::JoinTo<table>,
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type FromClause = diesel::query_builder::Tablesample<S, TSM>;
            type OnClause = <diesel::query_builder::Tablesample<
                S,
                TSM,
            > as diesel::JoinTo<table>>::OnClause;
            fn join_target(
                __diesel_internal_rhs: diesel::query_builder::Tablesample<S, TSM>,
            ) -> (Self::FromClause, Self::OnClause) {
                let (_, __diesel_internal_on_clause) = diesel::query_builder::Tablesample::<
                    S,
                    TSM,
                >::join_target(table);
                (__diesel_internal_rhs, __diesel_internal_on_clause)
            }
        }
        impl<
            TSM,
        > diesel::query_source::AppearsInFromClause<
            diesel::query_builder::Tablesample<table, TSM>,
        > for table
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        impl<TSM> diesel::query_source::AppearsInFromClause<table>
        for diesel::query_builder::Tablesample<table, TSM>
        where
            TSM: diesel::internal::table_macro::TablesampleMethod,
        {
            type Count = diesel::query_source::Once;
        }
        /// Contains all of the columns of this table
        pub mod columns {
            use ::diesel;
            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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for star {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "star")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for star {
                #[inline]
                fn clone(&self) -> star {
                    *self
                }
            }
            #[automatically_derived]
            #[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,
                    document,
                    pattern,
                    subject,
                    redirect,
                ): diesel::expression::ValidGrouping<__GB>,
            {
                type IsAggregate = <(
                    id,
                    document,
                    pattern,
                    subject,
                    redirect,
                ) 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<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    use diesel::QuerySource;
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_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(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for id {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "id")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for id {
                #[inline]
                fn clone(&self) -> id {
                    *self
                }
            }
            #[automatically_derived]
            #[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(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 = Uuid;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for id
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("id")
                }
            }
            impl diesel::SelectableExpression<super::table> for id {}
            impl<QS> diesel::AppearsOnTable<QS> for id
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for id
            where
                id: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for id
            where
                id: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for id
            where
                From: diesel::query_source::QuerySource,
                id: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<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 = super::table;
                const NAME: &'static str = "id";
            }
            impl<T> diesel::EqAll<T> for id
            where
                T: diesel::expression::AsExpression<Uuid>,
                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, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for id {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for id {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for id
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct document;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for document {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "document")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for document {
                #[inline]
                fn clone(&self) -> document {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for document {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for document {
                    type QueryId = document;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for document {
                #[inline]
                fn default() -> document {
                    document {}
                }
            }
            impl diesel::expression::Expression for document {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for document
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("document")
                }
            }
            impl diesel::SelectableExpression<super::table> for document {}
            impl<QS> diesel::AppearsOnTable<QS> for document
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for document
            where
                document: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for document
            where
                document: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for document
            where
                From: diesel::query_source::QuerySource,
                document: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for document
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    document,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for document {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for document {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for document {
                type Table = super::table;
                const NAME: &'static str = "document";
            }
            impl<T> diesel::EqAll<T> for document
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    document,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for document {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for document {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for document
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct pattern;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for pattern {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "pattern")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for pattern {
                #[inline]
                fn clone(&self) -> pattern {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for pattern {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for pattern {
                    type QueryId = pattern;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for pattern {
                #[inline]
                fn default() -> pattern {
                    pattern {}
                }
            }
            impl diesel::expression::Expression for pattern {
                type SqlType = Bpchar;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for pattern
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("pattern")
                }
            }
            impl diesel::SelectableExpression<super::table> for pattern {}
            impl<QS> diesel::AppearsOnTable<QS> for pattern
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for pattern
            where
                pattern: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for pattern
            where
                pattern: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for pattern
            where
                From: diesel::query_source::QuerySource,
                pattern: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for pattern
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    pattern,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for pattern {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for pattern {
                type Table = super::table;
                const NAME: &'static str = "pattern";
            }
            impl<T> diesel::EqAll<T> for pattern
            where
                T: diesel::expression::AsExpression<Bpchar>,
                diesel::dsl::Eq<
                    pattern,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for pattern {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for pattern {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for pattern
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct subject;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for subject {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "subject")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for subject {
                #[inline]
                fn clone(&self) -> subject {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for subject {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for subject {
                    type QueryId = subject;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for subject {
                #[inline]
                fn default() -> subject {
                    subject {}
                }
            }
            impl diesel::expression::Expression for subject {
                type SqlType = Nullable<Bpchar>;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for subject
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("subject")
                }
            }
            impl diesel::SelectableExpression<super::table> for subject {}
            impl<QS> diesel::AppearsOnTable<QS> for subject
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for subject
            where
                subject: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for subject
            where
                subject: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for subject
            where
                subject: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for subject
            where
                From: diesel::query_source::QuerySource,
                subject: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for subject
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    subject,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for subject {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<subject> for subject {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for subject {
                type Table = super::table;
                const NAME: &'static str = "subject";
            }
            impl<T> diesel::EqAll<T> for subject
            where
                T: diesel::expression::AsExpression<Nullable<Bpchar>>,
                diesel::dsl::Eq<
                    subject,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for subject {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for subject {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for subject
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for subject
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            #[allow(non_camel_case_types, dead_code)]
            pub struct redirect;
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::fmt::Debug for redirect {
                #[inline]
                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                    ::core::fmt::Formatter::write_str(f, "redirect")
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::clone::Clone for redirect {
                #[inline]
                fn clone(&self) -> redirect {
                    *self
                }
            }
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::marker::Copy for redirect {}
            #[allow(unused_imports)]
            const _: () = {
                use diesel;
                use diesel::query_builder::QueryId;
                #[allow(non_camel_case_types)]
                impl QueryId for redirect {
                    type QueryId = redirect;
                    const HAS_STATIC_QUERY_ID: bool = true;
                }
            };
            #[automatically_derived]
            #[allow(non_camel_case_types, dead_code)]
            impl ::core::default::Default for redirect {
                #[inline]
                fn default() -> redirect {
                    redirect {}
                }
            }
            impl diesel::expression::Expression for redirect {
                type SqlType = Nullable<Bpchar>;
            }
            impl<DB> diesel::query_builder::QueryFragment<DB> for redirect
            where
                DB: diesel::backend::Backend,
                diesel::internal::table_macro::StaticQueryFragmentInstance<
                    table,
                >: diesel::query_builder::QueryFragment<DB>,
            {
                #[allow(non_snake_case)]
                fn walk_ast<'b>(
                    &'b self,
                    mut __diesel_internal_out: diesel::query_builder::AstPass<'_, 'b, DB>,
                ) -> diesel::result::QueryResult<()> {
                    if !__diesel_internal_out.should_skip_from() {
                        const FROM_CLAUSE: diesel::internal::table_macro::StaticQueryFragmentInstance<
                            table,
                        > = diesel::internal::table_macro::StaticQueryFragmentInstance::new();
                        FROM_CLAUSE.walk_ast(__diesel_internal_out.reborrow())?;
                        __diesel_internal_out.push_sql(".");
                    }
                    __diesel_internal_out.push_identifier("redirect")
                }
            }
            impl diesel::SelectableExpression<super::table> for redirect {}
            impl<QS> diesel::AppearsOnTable<QS> for redirect
            where
                QS: diesel::query_source::AppearsInFromClause<
                    super::table,
                    Count = diesel::query_source::Once,
                >,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::LeftOuter,
                >,
            > for redirect
            where
                redirect: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::LeftOuter,
                    >,
                >,
                Self: diesel::SelectableExpression<Left>,
                Right: diesel::query_source::AppearsInFromClause<
                        super::table,
                        Count = diesel::query_source::Never,
                    > + diesel::query_source::QuerySource,
                Left: diesel::query_source::QuerySource,
            {}
            impl<
                Left,
                Right,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::Join<
                    Left,
                    Right,
                    diesel::internal::table_macro::Inner,
                >,
            > for redirect
            where
                redirect: diesel::AppearsOnTable<
                    diesel::internal::table_macro::Join<
                        Left,
                        Right,
                        diesel::internal::table_macro::Inner,
                    >,
                >,
                Left: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                Right: diesel::query_source::AppearsInFromClause<super::table>
                    + diesel::query_source::QuerySource,
                (
                    Left::Count,
                    Right::Count,
                ): diesel::internal::table_macro::Pick<Left, Right>,
                Self: diesel::SelectableExpression<
                    <(
                        Left::Count,
                        Right::Count,
                    ) as diesel::internal::table_macro::Pick<Left, Right>>::Selection,
                >,
            {}
            impl<
                Join,
                On,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::JoinOn<Join, On>,
            > for redirect
            where
                redirect: diesel::SelectableExpression<Join>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::JoinOn<Join, On>,
                    >,
            {}
            impl<
                From,
            > diesel::SelectableExpression<
                diesel::internal::table_macro::SelectStatement<
                    diesel::internal::table_macro::FromClause<From>,
                >,
            > for redirect
            where
                From: diesel::query_source::QuerySource,
                redirect: diesel::SelectableExpression<From>
                    + diesel::AppearsOnTable<
                        diesel::internal::table_macro::SelectStatement<
                            diesel::internal::table_macro::FromClause<From>,
                        >,
                    >,
            {}
            impl<__GB> diesel::expression::ValidGrouping<__GB> for redirect
            where
                __GB: diesel::expression::IsContainedInGroupBy<
                    redirect,
                    Output = diesel::expression::is_contained_in_group_by::Yes,
                >,
            {
                type IsAggregate = diesel::expression::is_aggregate::Yes;
            }
            impl diesel::expression::ValidGrouping<()> for redirect {
                type IsAggregate = diesel::expression::is_aggregate::No;
            }
            impl diesel::expression::IsContainedInGroupBy<redirect> for redirect {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::query_source::Column for redirect {
                type Table = super::table;
                const NAME: &'static str = "redirect";
            }
            impl<T> diesel::EqAll<T> for redirect
            where
                T: diesel::expression::AsExpression<Nullable<Bpchar>>,
                diesel::dsl::Eq<
                    redirect,
                    T::Expression,
                >: diesel::Expression<SqlType = diesel::sql_types::Bool>,
            {
                type Output = diesel::dsl::Eq<Self, T::Expression>;
                fn eq_all(self, __diesel_internal_rhs: T) -> Self::Output {
                    use diesel::expression_methods::ExpressionMethods;
                    self.eq(__diesel_internal_rhs)
                }
            }
            impl diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Only<super::table>,
            > for redirect {
                type Count = diesel::query_source::Once;
            }
            impl diesel::SelectableExpression<diesel::query_builder::Only<super::table>>
            for redirect {}
            impl<
                TSM,
            > diesel::query_source::AppearsInFromClause<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for redirect
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {
                type Count = diesel::query_source::Once;
            }
            impl<
                TSM,
            > diesel::SelectableExpression<
                diesel::query_builder::Tablesample<super::table, TSM>,
            > for redirect
            where
                TSM: diesel::internal::table_macro::TablesampleMethod,
            {}
            impl diesel::expression::IsContainedInGroupBy<id> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for subject {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<subject> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<id> for redirect {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<redirect> for id {
                type Output = diesel::expression::is_contained_in_group_by::Yes;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for subject {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<subject> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<document> for redirect {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<redirect> for document {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for subject {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<subject> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<pattern> for redirect {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<redirect> for pattern {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<subject> for redirect {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
            impl diesel::expression::IsContainedInGroupBy<redirect> for subject {
                type Output = diesel::expression::is_contained_in_group_by::No;
            }
        }
    }
    impl ::diesel::JoinTo<meta_links::table> for meta_link_properties::table {
        type FromClause = meta_links::table;
        type OnClause = ::diesel::dsl::Eq<
            ::diesel::internal::table_macro::NullableExpression<
                meta_link_properties::meta_link_id,
            >,
            ::diesel::internal::table_macro::NullableExpression<
                <meta_links::table as ::diesel::query_source::Table>::PrimaryKey,
            >,
        >;
        fn join_target(rhs: meta_links::table) -> (Self::FromClause, Self::OnClause) {
            use ::diesel::{ExpressionMethods, NullableExpressionMethods};
            (
                rhs,
                meta_link_properties::meta_link_id
                    .nullable()
                    .eq(
                        <meta_links::table as ::diesel::query_source::Table>::primary_key(
                                &meta_links::table,
                            )
                            .nullable(),
                    ),
            )
        }
    }
    impl ::diesel::JoinTo<meta_link_properties::table> for meta_links::table {
        type FromClause = meta_link_properties::table;
        type OnClause = ::diesel::dsl::Eq<
            ::diesel::internal::table_macro::NullableExpression<
                meta_link_properties::meta_link_id,
            >,
            ::diesel::internal::table_macro::NullableExpression<
                <meta_links::table as ::diesel::query_source::Table>::PrimaryKey,
            >,
        >;
        fn join_target(
            rhs: meta_link_properties::table,
        ) -> (Self::FromClause, Self::OnClause) {
            use ::diesel::{ExpressionMethods, NullableExpressionMethods};
            (
                rhs,
                meta_link_properties::meta_link_id
                    .nullable()
                    .eq(
                        <meta_links::table as ::diesel::query_source::Table>::primary_key(
                                &meta_links::table,
                            )
                            .nullable(),
                    ),
            )
        }
    }
    impl ::diesel::JoinTo<meta_links::table> for meta_link_titles::table {
        type FromClause = meta_links::table;
        type OnClause = ::diesel::dsl::Eq<
            ::diesel::internal::table_macro::NullableExpression<
                meta_link_titles::meta_link_id,
            >,
            ::diesel::internal::table_macro::NullableExpression<
                <meta_links::table as ::diesel::query_source::Table>::PrimaryKey,
            >,
        >;
        fn join_target(rhs: meta_links::table) -> (Self::FromClause, Self::OnClause) {
            use ::diesel::{ExpressionMethods, NullableExpressionMethods};
            (
                rhs,
                meta_link_titles::meta_link_id
                    .nullable()
                    .eq(
                        <meta_links::table as ::diesel::query_source::Table>::primary_key(
                                &meta_links::table,
                            )
                            .nullable(),
                    ),
            )
        }
    }
    impl ::diesel::JoinTo<meta_link_titles::table> for meta_links::table {
        type FromClause = meta_link_titles::table;
        type OnClause = ::diesel::dsl::Eq<
            ::diesel::internal::table_macro::NullableExpression<
                meta_link_titles::meta_link_id,
            >,
            ::diesel::internal::table_macro::NullableExpression<
                <meta_links::table as ::diesel::query_source::Table>::PrimaryKey,
            >,
        >;
        fn join_target(
            rhs: meta_link_titles::table,
        ) -> (Self::FromClause, Self::OnClause) {
            use ::diesel::{ExpressionMethods, NullableExpressionMethods};
            (
                rhs,
                meta_link_titles::meta_link_id
                    .nullable()
                    .eq(
                        <meta_links::table as ::diesel::query_source::Table>::primary_key(
                                &meta_links::table,
                            )
                            .nullable(),
                    ),
            )
        }
    }
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for meta_link_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for meta_aliases::table {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Only<meta_link_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Only<meta_aliases::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_aliases::table>,
    > for meta_link_properties::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_properties::table>,
    > for meta_aliases::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>,
    > for meta_link_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>,
    > for meta_aliases::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for meta_link_titles::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for meta_aliases::table {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Only<meta_link_titles::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Only<meta_aliases::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_aliases::table>,
    > for meta_link_titles::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_titles::table>,
    > for meta_aliases::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>,
    > for meta_link_titles::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>,
    > for meta_aliases::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for meta_aliases::table {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Only<meta_links::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Only<meta_aliases::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_aliases::table>,
    > for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_links::table>,
    > for meta_aliases::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Tablesample<meta_links::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>,
    > for meta_links::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_links::table, TSM>,
    > for meta_aliases::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for meta_aliases::table {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Only<meta_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Only<meta_aliases::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_aliases::table>,
    > for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_properties::table>,
    > for meta_aliases::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Tablesample<meta_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>,
    > for meta_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_properties::table, TSM>,
    > for meta_aliases::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for meta_aliases::table {}
    impl ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Only<meta_subjects::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Only<meta_aliases::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_aliases::table>,
    > for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_subjects::table>,
    > for meta_aliases::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_aliases::table>
    for ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_aliases::table, TSM>,
    > for meta_subjects::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>,
    > for meta_aliases::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for meta_link_titles::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for meta_link_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Only<meta_link_titles::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Only<meta_link_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_properties::table>,
    > for meta_link_titles::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_titles::table>,
    > for meta_link_properties::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>,
    > for meta_link_titles::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>,
    > for meta_link_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for meta_link_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Only<meta_links::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Only<meta_link_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_properties::table>,
    > for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_links::table>,
    > for meta_link_properties::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Tablesample<meta_links::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>,
    > for meta_links::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_links::table, TSM>,
    > for meta_link_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for meta_link_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Only<meta_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Only<meta_link_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_properties::table>,
    > for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_properties::table>,
    > for meta_link_properties::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Tablesample<meta_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>,
    > for meta_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_properties::table, TSM>,
    > for meta_link_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for meta_link_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Only<meta_subjects::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Only<meta_link_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_properties::table>,
    > for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_subjects::table>,
    > for meta_link_properties::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_properties::table>
    for ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_properties::table, TSM>,
    > for meta_subjects::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>,
    > for meta_link_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for meta_link_titles::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Only<meta_links::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Only<meta_link_titles::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_titles::table>,
    > for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_links::table>,
    > for meta_link_titles::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Tablesample<meta_links::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>,
    > for meta_links::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_links::table, TSM>,
    > for meta_link_titles::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for meta_link_titles::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Only<meta_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Only<meta_link_titles::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_titles::table>,
    > for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_properties::table>,
    > for meta_link_titles::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Tablesample<meta_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>,
    > for meta_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_properties::table, TSM>,
    > for meta_link_titles::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for meta_link_titles::table {}
    impl ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Only<meta_subjects::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Only<meta_link_titles::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_link_titles::table>,
    > for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_subjects::table>,
    > for meta_link_titles::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_link_titles::table>
    for ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_link_titles::table, TSM>,
    > for meta_subjects::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>,
    > for meta_link_titles::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Only<meta_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Only<meta_links::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_links::table>,
    > for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_properties::table>,
    > for meta_links::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Tablesample<meta_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Tablesample<meta_links::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_links::table, TSM>,
    > for meta_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_properties::table, TSM>,
    > for meta_links::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for meta_links::table {}
    impl ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Only<meta_subjects::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Only<meta_links::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_links::table>,
    > for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_subjects::table>,
    > for meta_links::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_links::table>
    for ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Tablesample<meta_links::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_links::table, TSM>,
    > for meta_subjects::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>,
    > for meta_links::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for meta_properties::table {}
    impl ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Only<meta_subjects::table> {}
    impl ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Only<meta_properties::table> {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_properties::table>,
    > for meta_subjects::table {}
    impl ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Only<meta_subjects::table>,
    > for meta_properties::table {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_properties::table>
    for ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<TSM> ::diesel::query_source::TableNotEqual<meta_subjects::table>
    for ::diesel::query_builder::Tablesample<meta_properties::table, TSM>
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_properties::table, TSM>,
    > for meta_subjects::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
    impl<
        TSM,
    > ::diesel::query_source::TableNotEqual<
        ::diesel::query_builder::Tablesample<meta_subjects::table, TSM>,
    > for meta_properties::table
    where
        TSM: ::diesel::internal::table_macro::TablesampleMethod,
    {}
}
pub mod meta {
    //! Tables related to web page metadata, XRD and JRD, `host-meta`, `WebFinger`, and so on.
    //!
    //! # Intended usage
    //!
    //! 1. An user agent requests an application for the descriptor for a given resource;
    //! 2. **The application queries the database using these structures to:**
    //! 	1. [Determine if a descriptor should be returned, or if it should be handled by another application](MetaSubject);
    //! 	2. [Determine which aliases the resource has](MetaAlias);
    //! 	3. [Determine which properties the resource has](MetaProperty);
    //! 	4. [Determine which links the resource has](MetaLink);
    //! 	5. [Determine the titles of each link](MetaLinkTitle);
    //! 	6. [Determine the properties of each link](MetaLinkProperty);
    //! 3. The application compiles the data in a single structure that the user agent supports
    //! 4. The application returns the data to the user agent
    //!
    //! # Matching
    //!
    //! Matching is performed for each single record separately, allowing for example a system administrator to define many separate subjects while globally defining a property for all the resources served.
    //!
    //! # Reference
    //!
    //! See [`acrate_rd`] for more information on the specification these structures are based on.
    //!
    //! # Used by
    //!
    //! - [`acrate_rdserver`]
    //!
    use diesel::deserialize::FromSql;
    use diesel::{
        AsExpression, Associations, FromSqlRow, Identifiable, Insertable, IntoSql,
        PgTextExpressionMethods, QueryResult, Queryable, QueryableByName, Selectable,
        SelectableHelper, ExpressionMethods, BelongingToDsl,
    };
    use diesel::dsl::insert_into;
    use diesel::pg::{Pg, PgConnection};
    use diesel::serialize::{Output, ToSql};
    use diesel_async::AsyncPgConnection;
    use mediatype::MediaTypeBuf;
    use uuid::Uuid;
    use crate::traits::ToInserted;
    use super::schema;
    /// Wrapper to use [`mime::Mime`] with [`diesel`].
    #[diesel(sql_type = diesel::sql_types::Text)]
    pub struct MediaTypeDatabase(pub MediaTypeBuf);
    #[automatically_derived]
    impl ::core::fmt::Debug for MediaTypeDatabase {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_tuple_field1_finish(
                f,
                "MediaTypeDatabase",
                &&self.0,
            )
        }
    }
    #[automatically_derived]
    impl ::core::clone::Clone for MediaTypeDatabase {
        #[inline]
        fn clone(&self) -> MediaTypeDatabase {
            MediaTypeDatabase(::core::clone::Clone::clone(&self.0))
        }
    }
    #[automatically_derived]
    impl ::core::marker::StructuralPartialEq for MediaTypeDatabase {}
    #[automatically_derived]
    impl ::core::cmp::PartialEq for MediaTypeDatabase {
        #[inline]
        fn eq(&self, other: &MediaTypeDatabase) -> bool {
            self.0 == other.0
        }
    }
    #[automatically_derived]
    impl ::core::cmp::Eq for MediaTypeDatabase {
        #[inline]
        #[doc(hidden)]
        #[coverage(off)]
        fn assert_receiver_is_total_eq(&self) -> () {
            let _: ::core::cmp::AssertParamIsEq<MediaTypeBuf>;
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, FromSql, Queryable};
        impl<__DB, __ST> Queryable<__ST, __DB> for MediaTypeDatabase
        where
            __DB: diesel::backend::Backend,
            __ST: diesel::sql_types::SingleValue,
            Self: FromSql<__ST, __DB>,
        {
            type Row = Self;
            fn build(row: Self::Row) -> deserialize::Result<Self> {
                Ok(row)
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::expression::AsExpression;
        use diesel::internal::derives::as_expression::Bound;
        use diesel::sql_types::Nullable;
        use diesel::serialize::{self, ToSql, Output};
        impl<'__expr> AsExpression<diesel::sql_types::Text>
        for &'__expr MediaTypeDatabase {
            type Expression = Bound<diesel::sql_types::Text, Self>;
            fn as_expression(self) -> Self::Expression {
                Bound::new(self)
            }
        }
        impl<'__expr> AsExpression<Nullable<diesel::sql_types::Text>>
        for &'__expr MediaTypeDatabase {
            type Expression = Bound<Nullable<diesel::sql_types::Text>, Self>;
            fn as_expression(self) -> Self::Expression {
                Bound::new(self)
            }
        }
        impl<'__expr, '__expr2> AsExpression<diesel::sql_types::Text>
        for &'__expr2 &'__expr MediaTypeDatabase {
            type Expression = Bound<diesel::sql_types::Text, Self>;
            fn as_expression(self) -> Self::Expression {
                Bound::new(self)
            }
        }
        impl<'__expr, '__expr2> AsExpression<Nullable<diesel::sql_types::Text>>
        for &'__expr2 &'__expr MediaTypeDatabase {
            type Expression = Bound<Nullable<diesel::sql_types::Text>, Self>;
            fn as_expression(self) -> Self::Expression {
                Bound::new(self)
            }
        }
        impl<__DB> diesel::serialize::ToSql<Nullable<diesel::sql_types::Text>, __DB>
        for MediaTypeDatabase
        where
            __DB: diesel::backend::Backend,
            Self: ToSql<diesel::sql_types::Text, __DB>,
        {
            fn to_sql<'__b>(
                &'__b self,
                out: &mut Output<'__b, '_, __DB>,
            ) -> serialize::Result {
                ToSql::<diesel::sql_types::Text, __DB>::to_sql(self, out)
            }
        }
        impl AsExpression<diesel::sql_types::Text> for MediaTypeDatabase {
            type Expression = Bound<diesel::sql_types::Text, Self>;
            fn as_expression(self) -> Self::Expression {
                Bound::new(self)
            }
        }
        impl AsExpression<Nullable<diesel::sql_types::Text>> for MediaTypeDatabase {
            type Expression = Bound<Nullable<diesel::sql_types::Text>, Self>;
            fn as_expression(self) -> Self::Expression {
                Bound::new(self)
            }
        }
    };
    /// A matchable record denoting the existence of a resource descriptor.
    ///
    /// # See also
    ///
    /// - [`MetaSubjectInsert`]
    ///
    #[diesel(table_name = schema::meta_subjects)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaSubject {
        /// The identity column of the record.
        pub id: Uuid,
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The value the `subject` property should take when this record is matched.
        ///
        /// If [`None`], its value is up for specification by the querying application.
        pub subject: Option<String>,
        /// Where the querying application should redirect the user agent to when this record is matched.
        ///
        /// If [`Some`], should always override everything else.
        pub redirect: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaSubject {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field5_finish(
                f,
                "MetaSubject",
                "id",
                &self.id,
                "document",
                &self.document,
                "pattern",
                &self.pattern,
                "subject",
                &self.subject,
                "redirect",
                &&self.redirect,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, FromStaticSqlRow, Queryable};
        use diesel::row::{Row as _, Field as _};
        use std::convert::TryInto;
        impl<
            __DB: diesel::backend::Backend,
            __ST0,
            __ST1,
            __ST2,
            __ST3,
            __ST4,
        > Queryable<(__ST0, __ST1, __ST2, __ST3, __ST4), __DB> for MetaSubject
        where
            (
                Uuid,
                String,
                String,
                Option<String>,
                Option<String>,
            ): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3, __ST4), __DB>,
        {
            type Row = (Uuid, String, String, Option<String>, Option<String>);
            fn build(row: Self::Row) -> deserialize::Result<Self> {
                Ok(Self {
                    id: row.0.try_into()?,
                    document: row.1.try_into()?,
                    pattern: row.2.try_into()?,
                    subject: row.3.try_into()?,
                    redirect: row.4.try_into()?,
                })
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, QueryableByName};
        use diesel::row::NamedRow;
        use diesel::sql_types::Untyped;
        impl<__DB: diesel::backend::Backend> QueryableByName<__DB> for MetaSubject
        where
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::id>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::document>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::pattern>,
                __DB,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::subject>,
                __DB,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::redirect>,
                __DB,
            >,
        {
            fn build<'__a>(
                row: &impl NamedRow<'__a, __DB>,
            ) -> deserialize::Result<Self> {
                let mut id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_subjects::id>,
                        Uuid,
                    >(row, "id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut document = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_subjects::document>,
                        String,
                    >(row, "document")?;
                    <String as Into<String>>::into(field)
                };
                let mut pattern = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_subjects::pattern>,
                        String,
                    >(row, "pattern")?;
                    <String as Into<String>>::into(field)
                };
                let mut subject = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_subjects::subject>,
                        Option<String>,
                    >(row, "subject")?;
                    <Option<String> as Into<Option<String>>>::into(field)
                };
                let mut redirect = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_subjects::redirect>,
                        Option<String>,
                    >(row, "redirect")?;
                    <Option<String> as Into<Option<String>>>::into(field)
                };
                deserialize::Result::Ok(Self {
                    id: id,
                    document: document,
                    pattern: pattern,
                    subject: subject,
                    redirect: redirect,
                })
            }
        }
        fn _check_field_compatibility()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::pattern>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::subject>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::redirect>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::associations::{HasTable, Identifiable};
        impl HasTable for MetaSubject {
            type Table = schema::meta_subjects::table;
            fn table() -> Self::Table {
                schema::meta_subjects::table
            }
        }
        impl<'ident> Identifiable for &'ident MetaSubject {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
        impl<'ident> Identifiable for &'_ &'ident MetaSubject {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::expression::Selectable;
        impl<__DB: diesel::backend::Backend> Selectable<__DB> for MetaSubject {
            type SelectExpression = (
                schema::meta_subjects::id,
                schema::meta_subjects::document,
                schema::meta_subjects::pattern,
                schema::meta_subjects::subject,
                schema::meta_subjects::redirect,
            );
            fn construct_selection() -> Self::SelectExpression {
                (
                    schema::meta_subjects::id,
                    schema::meta_subjects::document,
                    schema::meta_subjects::pattern,
                    schema::meta_subjects::subject,
                    schema::meta_subjects::redirect,
                )
            }
        }
        fn _check_field_compatibility<__DB: diesel::backend::Backend>()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::pattern>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::subject>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_subjects::redirect>,
                Pg,
            >,
        {}
    };
    /// An [`Insertable`] version of [`MetaSubject`].
    #[diesel(table_name = schema::meta_subjects)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaSubjectInsert {
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The value the `subject` property should take when this record is matched.
        ///
        /// If [`None`], its value is up for specification by the querying application.
        pub subject: Option<String>,
        /// Where the querying application should redirect the user agent to when this record is matched.
        ///
        /// If [`Some`], should always override everything else.
        pub redirect: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaSubjectInsert {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field4_finish(
                f,
                "MetaSubjectInsert",
                "document",
                &self.document,
                "pattern",
                &self.pattern,
                "subject",
                &self.subject,
                "redirect",
                &&self.redirect,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::insertable::Insertable;
        use diesel::internal::derives::insertable::UndecoratedInsertRecord;
        use diesel::prelude::*;
        #[allow(unused_qualifications)]
        impl Insertable<schema::meta_subjects::table> for MetaSubjectInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::pattern, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::subject, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::redirect, String>,
                >,
            ) as Insertable<schema::meta_subjects::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::pattern, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::subject, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::redirect, String>,
                >,
            ) as Insertable<schema::meta_subjects::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_subjects::document.eq(self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_subjects::pattern.eq(self.pattern),
                    ),
                    self.subject.map(|x| schema::meta_subjects::subject.eq(x)),
                    self.redirect.map(|x| schema::meta_subjects::redirect.eq(x)),
                )
                    .values()
            }
        }
        #[allow(unused_qualifications)]
        impl<'insert> Insertable<schema::meta_subjects::table>
        for &'insert MetaSubjectInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::subject, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::redirect, &'insert String>,
                >,
            ) as Insertable<schema::meta_subjects::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::subject, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_subjects::redirect, &'insert String>,
                >,
            ) as Insertable<schema::meta_subjects::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_subjects::document.eq(&self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_subjects::pattern.eq(&self.pattern),
                    ),
                    self.subject.as_ref().map(|x| schema::meta_subjects::subject.eq(x)),
                    self.redirect.as_ref().map(|x| schema::meta_subjects::redirect.eq(x)),
                )
                    .values()
            }
        }
        impl UndecoratedInsertRecord<schema::meta_subjects::table>
        for MetaSubjectInsert {}
    };
    /// A matchable record denoting an alias belonging to a subject.
    ///
    /// # See also
    ///
    /// - [`MetaAliasInsert`]
    ///
    #[diesel(table_name = schema::meta_aliases)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaAlias {
        /// The identity column of the record.
        pub id: Uuid,
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The alias to **add** to the list of aliases of the resource.
        pub alias: String,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaAlias {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field4_finish(
                f,
                "MetaAlias",
                "id",
                &self.id,
                "document",
                &self.document,
                "pattern",
                &self.pattern,
                "alias",
                &&self.alias,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, FromStaticSqlRow, Queryable};
        use diesel::row::{Row as _, Field as _};
        use std::convert::TryInto;
        impl<
            __DB: diesel::backend::Backend,
            __ST0,
            __ST1,
            __ST2,
            __ST3,
        > Queryable<(__ST0, __ST1, __ST2, __ST3), __DB> for MetaAlias
        where
            (
                Uuid,
                String,
                String,
                String,
            ): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3), __DB>,
        {
            type Row = (Uuid, String, String, String);
            fn build(row: Self::Row) -> deserialize::Result<Self> {
                Ok(Self {
                    id: row.0.try_into()?,
                    document: row.1.try_into()?,
                    pattern: row.2.try_into()?,
                    alias: row.3.try_into()?,
                })
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, QueryableByName};
        use diesel::row::NamedRow;
        use diesel::sql_types::Untyped;
        impl<__DB: diesel::backend::Backend> QueryableByName<__DB> for MetaAlias
        where
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::id>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::document>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::pattern>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::alias>,
                __DB,
            >,
        {
            fn build<'__a>(
                row: &impl NamedRow<'__a, __DB>,
            ) -> deserialize::Result<Self> {
                let mut id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_aliases::id>,
                        Uuid,
                    >(row, "id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut document = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_aliases::document>,
                        String,
                    >(row, "document")?;
                    <String as Into<String>>::into(field)
                };
                let mut pattern = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_aliases::pattern>,
                        String,
                    >(row, "pattern")?;
                    <String as Into<String>>::into(field)
                };
                let mut alias = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_aliases::alias>,
                        String,
                    >(row, "alias")?;
                    <String as Into<String>>::into(field)
                };
                deserialize::Result::Ok(Self {
                    id: id,
                    document: document,
                    pattern: pattern,
                    alias: alias,
                })
            }
        }
        fn _check_field_compatibility()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::pattern>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::alias>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::associations::{HasTable, Identifiable};
        impl HasTable for MetaAlias {
            type Table = schema::meta_aliases::table;
            fn table() -> Self::Table {
                schema::meta_aliases::table
            }
        }
        impl<'ident> Identifiable for &'ident MetaAlias {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
        impl<'ident> Identifiable for &'_ &'ident MetaAlias {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::expression::Selectable;
        impl<__DB: diesel::backend::Backend> Selectable<__DB> for MetaAlias {
            type SelectExpression = (
                schema::meta_aliases::id,
                schema::meta_aliases::document,
                schema::meta_aliases::pattern,
                schema::meta_aliases::alias,
            );
            fn construct_selection() -> Self::SelectExpression {
                (
                    schema::meta_aliases::id,
                    schema::meta_aliases::document,
                    schema::meta_aliases::pattern,
                    schema::meta_aliases::alias,
                )
            }
        }
        fn _check_field_compatibility<__DB: diesel::backend::Backend>()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::pattern>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_aliases::alias>,
                Pg,
            >,
        {}
    };
    /// An [`Insertable`] version of [`MetaAlias`].
    #[diesel(table_name = schema::meta_aliases)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaAliasInsert {
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The alias to **add** to the list of aliases of the resource.
        pub alias: String,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaAliasInsert {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field3_finish(
                f,
                "MetaAliasInsert",
                "document",
                &self.document,
                "pattern",
                &self.pattern,
                "alias",
                &&self.alias,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::insertable::Insertable;
        use diesel::internal::derives::insertable::UndecoratedInsertRecord;
        use diesel::prelude::*;
        #[allow(unused_qualifications)]
        impl Insertable<schema::meta_aliases::table> for MetaAliasInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::pattern, String>,
                >,
                std::option::Option<diesel::dsl::Eq<schema::meta_aliases::alias, String>>,
            ) as Insertable<schema::meta_aliases::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::pattern, String>,
                >,
                std::option::Option<diesel::dsl::Eq<schema::meta_aliases::alias, String>>,
            ) as Insertable<schema::meta_aliases::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_aliases::document.eq(self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_aliases::pattern.eq(self.pattern),
                    ),
                    std::option::Option::Some(schema::meta_aliases::alias.eq(self.alias)),
                )
                    .values()
            }
        }
        #[allow(unused_qualifications)]
        impl<'insert> Insertable<schema::meta_aliases::table>
        for &'insert MetaAliasInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::alias, &'insert String>,
                >,
            ) as Insertable<schema::meta_aliases::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_aliases::alias, &'insert String>,
                >,
            ) as Insertable<schema::meta_aliases::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_aliases::document.eq(&self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_aliases::pattern.eq(&self.pattern),
                    ),
                    std::option::Option::Some(
                        schema::meta_aliases::alias.eq(&self.alias),
                    ),
                )
                    .values()
            }
        }
        impl UndecoratedInsertRecord<schema::meta_aliases::table> for MetaAliasInsert {}
    };
    /// A matchable record denoting a link towards another resource someway related with the subject.
    ///
    /// # See also
    ///
    /// - [`MetaLinkInsert`]
    ///
    #[diesel(table_name = schema::meta_links)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaLink {
        /// The identity column of the record.
        pub id: Uuid,
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The relationship the link establishes between itself and the value of the link.
        pub rel: String,
        /// The media type of the value of the link.
        ///
        /// Can be [`None`] if it shouldn't be specified.
        pub type_: Option<MediaTypeDatabase>,
        /// The URI to the document this property is linking the subject to.
        ///
        /// Can be [`None`] if it shouldn't be specified, for example if [`Self::template`] is [`Some`].
        pub href: Option<String>,
        /// The template to the document this property is linking the subject to.
        ///
        /// Can be [`None`] if it shouldn't be specified, for example if [`Self::href`] is [`Some`].
        pub template: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaLink {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            let names: &'static _ = &[
                "id",
                "document",
                "pattern",
                "rel",
                "type_",
                "href",
                "template",
            ];
            let values: &[&dyn ::core::fmt::Debug] = &[
                &self.id,
                &self.document,
                &self.pattern,
                &self.rel,
                &self.type_,
                &self.href,
                &&self.template,
            ];
            ::core::fmt::Formatter::debug_struct_fields_finish(
                f,
                "MetaLink",
                names,
                values,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, FromStaticSqlRow, Queryable};
        use diesel::row::{Row as _, Field as _};
        use std::convert::TryInto;
        impl<
            __DB: diesel::backend::Backend,
            __ST0,
            __ST1,
            __ST2,
            __ST3,
            __ST4,
            __ST5,
            __ST6,
        > Queryable<(__ST0, __ST1, __ST2, __ST3, __ST4, __ST5, __ST6), __DB> for MetaLink
        where
            (
                Uuid,
                String,
                String,
                String,
                Option<MediaTypeDatabase>,
                Option<String>,
                Option<String>,
            ): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3, __ST4, __ST5, __ST6), __DB>,
        {
            type Row = (
                Uuid,
                String,
                String,
                String,
                Option<MediaTypeDatabase>,
                Option<String>,
                Option<String>,
            );
            fn build(row: Self::Row) -> deserialize::Result<Self> {
                Ok(Self {
                    id: row.0.try_into()?,
                    document: row.1.try_into()?,
                    pattern: row.2.try_into()?,
                    rel: row.3.try_into()?,
                    type_: row.4.try_into()?,
                    href: row.5.try_into()?,
                    template: row.6.try_into()?,
                })
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, QueryableByName};
        use diesel::row::NamedRow;
        use diesel::sql_types::Untyped;
        impl<__DB: diesel::backend::Backend> QueryableByName<__DB> for MetaLink
        where
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_links::id>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_links::document>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_links::pattern>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_links::rel>,
                __DB,
            >,
            Option<
                MediaTypeDatabase,
            >: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_links::type_>,
                __DB,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_links::href>,
                __DB,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_links::template>,
                __DB,
            >,
        {
            fn build<'__a>(
                row: &impl NamedRow<'__a, __DB>,
            ) -> deserialize::Result<Self> {
                let mut id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_links::id>,
                        Uuid,
                    >(row, "id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut document = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_links::document>,
                        String,
                    >(row, "document")?;
                    <String as Into<String>>::into(field)
                };
                let mut pattern = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_links::pattern>,
                        String,
                    >(row, "pattern")?;
                    <String as Into<String>>::into(field)
                };
                let mut rel = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_links::rel>,
                        String,
                    >(row, "rel")?;
                    <String as Into<String>>::into(field)
                };
                let mut type_ = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_links::type_>,
                        Option<MediaTypeDatabase>,
                    >(row, "type_")?;
                    <Option<
                        MediaTypeDatabase,
                    > as Into<Option<MediaTypeDatabase>>>::into(field)
                };
                let mut href = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_links::href>,
                        Option<String>,
                    >(row, "href")?;
                    <Option<String> as Into<Option<String>>>::into(field)
                };
                let mut template = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_links::template>,
                        Option<String>,
                    >(row, "template")?;
                    <Option<String> as Into<Option<String>>>::into(field)
                };
                deserialize::Result::Ok(Self {
                    id: id,
                    document: document,
                    pattern: pattern,
                    rel: rel,
                    type_: type_,
                    href: href,
                    template: template,
                })
            }
        }
        fn _check_field_compatibility()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::pattern>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::rel>,
                Pg,
            >,
            Option<
                MediaTypeDatabase,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::type_>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::href>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::template>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::associations::{HasTable, Identifiable};
        impl HasTable for MetaLink {
            type Table = schema::meta_links::table;
            fn table() -> Self::Table {
                schema::meta_links::table
            }
        }
        impl<'ident> Identifiable for &'ident MetaLink {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
        impl<'ident> Identifiable for &'_ &'ident MetaLink {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::expression::Selectable;
        impl<__DB: diesel::backend::Backend> Selectable<__DB> for MetaLink {
            type SelectExpression = (
                schema::meta_links::id,
                schema::meta_links::document,
                schema::meta_links::pattern,
                schema::meta_links::rel,
                schema::meta_links::type_,
                schema::meta_links::href,
                schema::meta_links::template,
            );
            fn construct_selection() -> Self::SelectExpression {
                (
                    schema::meta_links::id,
                    schema::meta_links::document,
                    schema::meta_links::pattern,
                    schema::meta_links::rel,
                    schema::meta_links::type_,
                    schema::meta_links::href,
                    schema::meta_links::template,
                )
            }
        }
        fn _check_field_compatibility<__DB: diesel::backend::Backend>()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::pattern>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::rel>,
                Pg,
            >,
            Option<
                MediaTypeDatabase,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::type_>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::href>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_links::template>,
                Pg,
            >,
        {}
    };
    /// An [`Insertable`] version of [`MetaLink`].
    #[diesel(table_name = schema::meta_links)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaLinkInsert {
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The relationship the link establishes between itself and the value of the link.
        pub rel: String,
        /// The media type of the value of the link.
        ///
        /// Can be [`None`] if it shouldn't be specified.
        pub type_: Option<MediaTypeDatabase>,
        /// The URI to the document this property is linking the subject to.
        ///
        /// Can be [`None`] if it shouldn't be specified, for example if [`Self::template`] is [`Some`].
        pub href: Option<String>,
        /// The template to the document this property is linking the subject to.
        ///
        /// Can be [`None`] if it shouldn't be specified, for example if [`Self::href`] is [`Some`].
        pub template: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaLinkInsert {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            let names: &'static _ = &[
                "document",
                "pattern",
                "rel",
                "type_",
                "href",
                "template",
            ];
            let values: &[&dyn ::core::fmt::Debug] = &[
                &self.document,
                &self.pattern,
                &self.rel,
                &self.type_,
                &self.href,
                &&self.template,
            ];
            ::core::fmt::Formatter::debug_struct_fields_finish(
                f,
                "MetaLinkInsert",
                names,
                values,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::insertable::Insertable;
        use diesel::internal::derives::insertable::UndecoratedInsertRecord;
        use diesel::prelude::*;
        #[allow(unused_qualifications)]
        impl Insertable<schema::meta_links::table> for MetaLinkInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::pattern, String>,
                >,
                std::option::Option<diesel::dsl::Eq<schema::meta_links::rel, String>>,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::type_, MediaTypeDatabase>,
                >,
                std::option::Option<diesel::dsl::Eq<schema::meta_links::href, String>>,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::template, String>,
                >,
            ) as Insertable<schema::meta_links::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::pattern, String>,
                >,
                std::option::Option<diesel::dsl::Eq<schema::meta_links::rel, String>>,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::type_, MediaTypeDatabase>,
                >,
                std::option::Option<diesel::dsl::Eq<schema::meta_links::href, String>>,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::template, String>,
                >,
            ) as Insertable<schema::meta_links::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_links::document.eq(self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_links::pattern.eq(self.pattern),
                    ),
                    std::option::Option::Some(schema::meta_links::rel.eq(self.rel)),
                    self.type_.map(|x| schema::meta_links::type_.eq(x)),
                    self.href.map(|x| schema::meta_links::href.eq(x)),
                    self.template.map(|x| schema::meta_links::template.eq(x)),
                )
                    .values()
            }
        }
        #[allow(unused_qualifications)]
        impl<'insert> Insertable<schema::meta_links::table> for &'insert MetaLinkInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::rel, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<
                        schema::meta_links::type_,
                        &'insert MediaTypeDatabase,
                    >,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::href, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::template, &'insert String>,
                >,
            ) as Insertable<schema::meta_links::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::rel, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<
                        schema::meta_links::type_,
                        &'insert MediaTypeDatabase,
                    >,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::href, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_links::template, &'insert String>,
                >,
            ) as Insertable<schema::meta_links::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_links::document.eq(&self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_links::pattern.eq(&self.pattern),
                    ),
                    std::option::Option::Some(schema::meta_links::rel.eq(&self.rel)),
                    self.type_.as_ref().map(|x| schema::meta_links::type_.eq(x)),
                    self.href.as_ref().map(|x| schema::meta_links::href.eq(x)),
                    self.template.as_ref().map(|x| schema::meta_links::template.eq(x)),
                )
                    .values()
            }
        }
        impl UndecoratedInsertRecord<schema::meta_links::table> for MetaLinkInsert {}
    };
    /// A property that a [`MetaLink`] has.
    ///
    /// # See also
    ///
    /// - [`MetaLinkPropertyInsert`]
    ///
    #[diesel(belongs_to(MetaLink))]
    #[diesel(table_name = schema::meta_link_properties)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaLinkProperty {
        /// The identity column of the record.
        pub id: Uuid,
        /// The [`MetaLink::id`] this record refers to.
        pub meta_link_id: Uuid,
        /// The relationship the property establishes between the [`MetaLink`] and the [`MetaLinkProperty::value`].
        pub rel: String,
        /// The value that the property has.
        pub value: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaLinkProperty {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field4_finish(
                f,
                "MetaLinkProperty",
                "id",
                &self.id,
                "meta_link_id",
                &self.meta_link_id,
                "rel",
                &self.rel,
                "value",
                &&self.value,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, FromStaticSqlRow, Queryable};
        use diesel::row::{Row as _, Field as _};
        use std::convert::TryInto;
        impl<
            __DB: diesel::backend::Backend,
            __ST0,
            __ST1,
            __ST2,
            __ST3,
        > Queryable<(__ST0, __ST1, __ST2, __ST3), __DB> for MetaLinkProperty
        where
            (
                Uuid,
                Uuid,
                String,
                Option<String>,
            ): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3), __DB>,
        {
            type Row = (Uuid, Uuid, String, Option<String>);
            fn build(row: Self::Row) -> deserialize::Result<Self> {
                Ok(Self {
                    id: row.0.try_into()?,
                    meta_link_id: row.1.try_into()?,
                    rel: row.2.try_into()?,
                    value: row.3.try_into()?,
                })
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, QueryableByName};
        use diesel::row::NamedRow;
        use diesel::sql_types::Untyped;
        impl<__DB: diesel::backend::Backend> QueryableByName<__DB> for MetaLinkProperty
        where
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::id>,
                __DB,
            >,
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::meta_link_id>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::rel>,
                __DB,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::value>,
                __DB,
            >,
        {
            fn build<'__a>(
                row: &impl NamedRow<'__a, __DB>,
            ) -> deserialize::Result<Self> {
                let mut id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_link_properties::id>,
                        Uuid,
                    >(row, "id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut meta_link_id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<
                            schema::meta_link_properties::meta_link_id,
                        >,
                        Uuid,
                    >(row, "meta_link_id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut rel = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_link_properties::rel>,
                        String,
                    >(row, "rel")?;
                    <String as Into<String>>::into(field)
                };
                let mut value = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_link_properties::value>,
                        Option<String>,
                    >(row, "value")?;
                    <Option<String> as Into<Option<String>>>::into(field)
                };
                deserialize::Result::Ok(Self {
                    id: id,
                    meta_link_id: meta_link_id,
                    rel: rel,
                    value: value,
                })
            }
        }
        fn _check_field_compatibility()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::id>,
                Pg,
            >,
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::meta_link_id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::rel>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::value>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::associations::{HasTable, Identifiable};
        impl HasTable for MetaLinkProperty {
            type Table = schema::meta_link_properties::table;
            fn table() -> Self::Table {
                schema::meta_link_properties::table
            }
        }
        impl<'ident> Identifiable for &'ident MetaLinkProperty {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
        impl<'ident> Identifiable for &'_ &'ident MetaLinkProperty {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::expression::Selectable;
        impl<__DB: diesel::backend::Backend> Selectable<__DB> for MetaLinkProperty {
            type SelectExpression = (
                schema::meta_link_properties::id,
                schema::meta_link_properties::meta_link_id,
                schema::meta_link_properties::rel,
                schema::meta_link_properties::value,
            );
            fn construct_selection() -> Self::SelectExpression {
                (
                    schema::meta_link_properties::id,
                    schema::meta_link_properties::meta_link_id,
                    schema::meta_link_properties::rel,
                    schema::meta_link_properties::value,
                )
            }
        }
        fn _check_field_compatibility<__DB: diesel::backend::Backend>()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::id>,
                Pg,
            >,
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::meta_link_id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::rel>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_properties::value>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        impl<__FK> diesel::associations::BelongsTo<MetaLink> for MetaLinkProperty
        where
            __FK: std::hash::Hash + std::cmp::Eq,
            for<'__a> &'__a Uuid: std::convert::Into<::std::option::Option<&'__a __FK>>,
            for<'__a> &'__a MetaLink: diesel::associations::Identifiable<
                Id = &'__a __FK,
            >,
        {
            type ForeignKey = __FK;
            type ForeignKeyColumn = schema::meta_link_properties::meta_link_id;
            fn foreign_key(&self) -> std::option::Option<&Self::ForeignKey> {
                std::convert::Into::into(&self.meta_link_id)
            }
            fn foreign_key_column() -> Self::ForeignKeyColumn {
                schema::meta_link_properties::meta_link_id
            }
        }
        impl<__FK> diesel::associations::BelongsTo<&'_ MetaLink> for MetaLinkProperty
        where
            __FK: std::hash::Hash + std::cmp::Eq,
            for<'__a> &'__a Uuid: std::convert::Into<::std::option::Option<&'__a __FK>>,
            for<'__a> &'__a MetaLink: diesel::associations::Identifiable<
                Id = &'__a __FK,
            >,
        {
            type ForeignKey = __FK;
            type ForeignKeyColumn = schema::meta_link_properties::meta_link_id;
            fn foreign_key(&self) -> std::option::Option<&Self::ForeignKey> {
                std::convert::Into::into(&self.meta_link_id)
            }
            fn foreign_key_column() -> Self::ForeignKeyColumn {
                schema::meta_link_properties::meta_link_id
            }
        }
    };
    /// An [`Insertable`] version of [`MetaLinkProperty`].
    #[diesel(belongs_to(MetaLink))]
    #[diesel(table_name = schema::meta_link_properties)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaLinkPropertyInsert {
        /// The [`MetaLink::id`] this record refers to.
        pub meta_link_id: Uuid,
        /// The relationship the property establishes between the [`MetaLink`] and the [`MetaLinkProperty::value`].
        pub rel: String,
        /// The value that the property has.
        pub value: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaLinkPropertyInsert {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field3_finish(
                f,
                "MetaLinkPropertyInsert",
                "meta_link_id",
                &self.meta_link_id,
                "rel",
                &self.rel,
                "value",
                &&self.value,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::insertable::Insertable;
        use diesel::internal::derives::insertable::UndecoratedInsertRecord;
        use diesel::prelude::*;
        #[allow(unused_qualifications)]
        impl Insertable<schema::meta_link_properties::table> for MetaLinkPropertyInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::meta_link_id, Uuid>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::rel, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::value, String>,
                >,
            ) as Insertable<schema::meta_link_properties::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::meta_link_id, Uuid>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::rel, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::value, String>,
                >,
            ) as Insertable<schema::meta_link_properties::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_link_properties::meta_link_id.eq(self.meta_link_id),
                    ),
                    std::option::Option::Some(
                        schema::meta_link_properties::rel.eq(self.rel),
                    ),
                    self.value.map(|x| schema::meta_link_properties::value.eq(x)),
                )
                    .values()
            }
        }
        #[allow(unused_qualifications)]
        impl<'insert> Insertable<schema::meta_link_properties::table>
        for &'insert MetaLinkPropertyInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<
                        schema::meta_link_properties::meta_link_id,
                        &'insert Uuid,
                    >,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::rel, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::value, &'insert String>,
                >,
            ) as Insertable<schema::meta_link_properties::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<
                        schema::meta_link_properties::meta_link_id,
                        &'insert Uuid,
                    >,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::rel, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_properties::value, &'insert String>,
                >,
            ) as Insertable<schema::meta_link_properties::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_link_properties::meta_link_id.eq(&self.meta_link_id),
                    ),
                    std::option::Option::Some(
                        schema::meta_link_properties::rel.eq(&self.rel),
                    ),
                    self
                        .value
                        .as_ref()
                        .map(|x| schema::meta_link_properties::value.eq(x)),
                )
                    .values()
            }
        }
        impl UndecoratedInsertRecord<schema::meta_link_properties::table>
        for MetaLinkPropertyInsert {}
    };
    /// A title that a [`MetaLink`] has in a certain language.
    #[diesel(belongs_to(MetaLink))]
    #[diesel(table_name = schema::meta_link_titles)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaLinkTitle {
        /// The identity column of the record.
        pub id: Uuid,
        /// The [`MetaLink::id`] this record refers to.
        pub meta_link_id: Uuid,
        /// The language of the title.
        pub language: String,
        /// The actual contents of the title.
        pub value: String,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaLinkTitle {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field4_finish(
                f,
                "MetaLinkTitle",
                "id",
                &self.id,
                "meta_link_id",
                &self.meta_link_id,
                "language",
                &self.language,
                "value",
                &&self.value,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, FromStaticSqlRow, Queryable};
        use diesel::row::{Row as _, Field as _};
        use std::convert::TryInto;
        impl<
            __DB: diesel::backend::Backend,
            __ST0,
            __ST1,
            __ST2,
            __ST3,
        > Queryable<(__ST0, __ST1, __ST2, __ST3), __DB> for MetaLinkTitle
        where
            (
                Uuid,
                Uuid,
                String,
                String,
            ): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3), __DB>,
        {
            type Row = (Uuid, Uuid, String, String);
            fn build(row: Self::Row) -> deserialize::Result<Self> {
                Ok(Self {
                    id: row.0.try_into()?,
                    meta_link_id: row.1.try_into()?,
                    language: row.2.try_into()?,
                    value: row.3.try_into()?,
                })
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, QueryableByName};
        use diesel::row::NamedRow;
        use diesel::sql_types::Untyped;
        impl<__DB: diesel::backend::Backend> QueryableByName<__DB> for MetaLinkTitle
        where
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::id>,
                __DB,
            >,
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::meta_link_id>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::language>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::value>,
                __DB,
            >,
        {
            fn build<'__a>(
                row: &impl NamedRow<'__a, __DB>,
            ) -> deserialize::Result<Self> {
                let mut id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_link_titles::id>,
                        Uuid,
                    >(row, "id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut meta_link_id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_link_titles::meta_link_id>,
                        Uuid,
                    >(row, "meta_link_id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut language = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_link_titles::language>,
                        String,
                    >(row, "language")?;
                    <String as Into<String>>::into(field)
                };
                let mut value = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_link_titles::value>,
                        String,
                    >(row, "value")?;
                    <String as Into<String>>::into(field)
                };
                deserialize::Result::Ok(Self {
                    id: id,
                    meta_link_id: meta_link_id,
                    language: language,
                    value: value,
                })
            }
        }
        fn _check_field_compatibility()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::id>,
                Pg,
            >,
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::meta_link_id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::language>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::value>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::associations::{HasTable, Identifiable};
        impl HasTable for MetaLinkTitle {
            type Table = schema::meta_link_titles::table;
            fn table() -> Self::Table {
                schema::meta_link_titles::table
            }
        }
        impl<'ident> Identifiable for &'ident MetaLinkTitle {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
        impl<'ident> Identifiable for &'_ &'ident MetaLinkTitle {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::expression::Selectable;
        impl<__DB: diesel::backend::Backend> Selectable<__DB> for MetaLinkTitle {
            type SelectExpression = (
                schema::meta_link_titles::id,
                schema::meta_link_titles::meta_link_id,
                schema::meta_link_titles::language,
                schema::meta_link_titles::value,
            );
            fn construct_selection() -> Self::SelectExpression {
                (
                    schema::meta_link_titles::id,
                    schema::meta_link_titles::meta_link_id,
                    schema::meta_link_titles::language,
                    schema::meta_link_titles::value,
                )
            }
        }
        fn _check_field_compatibility<__DB: diesel::backend::Backend>()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::id>,
                Pg,
            >,
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::meta_link_id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::language>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_link_titles::value>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        impl<__FK> diesel::associations::BelongsTo<MetaLink> for MetaLinkTitle
        where
            __FK: std::hash::Hash + std::cmp::Eq,
            for<'__a> &'__a Uuid: std::convert::Into<::std::option::Option<&'__a __FK>>,
            for<'__a> &'__a MetaLink: diesel::associations::Identifiable<
                Id = &'__a __FK,
            >,
        {
            type ForeignKey = __FK;
            type ForeignKeyColumn = schema::meta_link_titles::meta_link_id;
            fn foreign_key(&self) -> std::option::Option<&Self::ForeignKey> {
                std::convert::Into::into(&self.meta_link_id)
            }
            fn foreign_key_column() -> Self::ForeignKeyColumn {
                schema::meta_link_titles::meta_link_id
            }
        }
        impl<__FK> diesel::associations::BelongsTo<&'_ MetaLink> for MetaLinkTitle
        where
            __FK: std::hash::Hash + std::cmp::Eq,
            for<'__a> &'__a Uuid: std::convert::Into<::std::option::Option<&'__a __FK>>,
            for<'__a> &'__a MetaLink: diesel::associations::Identifiable<
                Id = &'__a __FK,
            >,
        {
            type ForeignKey = __FK;
            type ForeignKeyColumn = schema::meta_link_titles::meta_link_id;
            fn foreign_key(&self) -> std::option::Option<&Self::ForeignKey> {
                std::convert::Into::into(&self.meta_link_id)
            }
            fn foreign_key_column() -> Self::ForeignKeyColumn {
                schema::meta_link_titles::meta_link_id
            }
        }
    };
    /// An [`Insertable`] version of [`MetaLinkTitle`].
    #[diesel(belongs_to(MetaLink))]
    #[diesel(table_name = schema::meta_link_titles)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaLinkTitleInsert {
        /// The [`MetaLink::id`] this record refers to.
        pub meta_link_id: Uuid,
        /// The language of the title.
        pub language: String,
        /// The actual contents of the title.
        pub value: String,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaLinkTitleInsert {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field3_finish(
                f,
                "MetaLinkTitleInsert",
                "meta_link_id",
                &self.meta_link_id,
                "language",
                &self.language,
                "value",
                &&self.value,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::insertable::Insertable;
        use diesel::internal::derives::insertable::UndecoratedInsertRecord;
        use diesel::prelude::*;
        #[allow(unused_qualifications)]
        impl Insertable<schema::meta_link_titles::table> for MetaLinkTitleInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::meta_link_id, Uuid>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::language, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::value, String>,
                >,
            ) as Insertable<schema::meta_link_titles::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::meta_link_id, Uuid>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::language, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::value, String>,
                >,
            ) as Insertable<schema::meta_link_titles::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_link_titles::meta_link_id.eq(self.meta_link_id),
                    ),
                    std::option::Option::Some(
                        schema::meta_link_titles::language.eq(self.language),
                    ),
                    std::option::Option::Some(
                        schema::meta_link_titles::value.eq(self.value),
                    ),
                )
                    .values()
            }
        }
        #[allow(unused_qualifications)]
        impl<'insert> Insertable<schema::meta_link_titles::table>
        for &'insert MetaLinkTitleInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<
                        schema::meta_link_titles::meta_link_id,
                        &'insert Uuid,
                    >,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::language, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::value, &'insert String>,
                >,
            ) as Insertable<schema::meta_link_titles::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<
                        schema::meta_link_titles::meta_link_id,
                        &'insert Uuid,
                    >,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::language, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_link_titles::value, &'insert String>,
                >,
            ) as Insertable<schema::meta_link_titles::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_link_titles::meta_link_id.eq(&self.meta_link_id),
                    ),
                    std::option::Option::Some(
                        schema::meta_link_titles::language.eq(&self.language),
                    ),
                    std::option::Option::Some(
                        schema::meta_link_titles::value.eq(&self.value),
                    ),
                )
                    .values()
            }
        }
        impl UndecoratedInsertRecord<schema::meta_link_titles::table>
        for MetaLinkTitleInsert {}
    };
    /// A matchable record denoting a property that a subject has.
    ///
    /// # See also
    ///
    /// - [`MetaPropertyInsert`]
    ///
    #[diesel(table_name = schema::meta_properties)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaProperty {
        /// The identity column of the record.
        pub id: Uuid,
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The relationship the property establishes between the [`MetaSubject`] and the [`MetaProperty::value`].
        pub rel: String,
        /// The value that the property has.
        pub value: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaProperty {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field5_finish(
                f,
                "MetaProperty",
                "id",
                &self.id,
                "document",
                &self.document,
                "pattern",
                &self.pattern,
                "rel",
                &self.rel,
                "value",
                &&self.value,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, FromStaticSqlRow, Queryable};
        use diesel::row::{Row as _, Field as _};
        use std::convert::TryInto;
        impl<
            __DB: diesel::backend::Backend,
            __ST0,
            __ST1,
            __ST2,
            __ST3,
            __ST4,
        > Queryable<(__ST0, __ST1, __ST2, __ST3, __ST4), __DB> for MetaProperty
        where
            (
                Uuid,
                String,
                String,
                String,
                Option<String>,
            ): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3, __ST4), __DB>,
        {
            type Row = (Uuid, String, String, String, Option<String>);
            fn build(row: Self::Row) -> deserialize::Result<Self> {
                Ok(Self {
                    id: row.0.try_into()?,
                    document: row.1.try_into()?,
                    pattern: row.2.try_into()?,
                    rel: row.3.try_into()?,
                    value: row.4.try_into()?,
                })
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::deserialize::{self, QueryableByName};
        use diesel::row::NamedRow;
        use diesel::sql_types::Untyped;
        impl<__DB: diesel::backend::Backend> QueryableByName<__DB> for MetaProperty
        where
            Uuid: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_properties::id>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_properties::document>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_properties::pattern>,
                __DB,
            >,
            String: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_properties::rel>,
                __DB,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSql<
                diesel::dsl::SqlTypeOf<schema::meta_properties::value>,
                __DB,
            >,
        {
            fn build<'__a>(
                row: &impl NamedRow<'__a, __DB>,
            ) -> deserialize::Result<Self> {
                let mut id = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_properties::id>,
                        Uuid,
                    >(row, "id")?;
                    <Uuid as Into<Uuid>>::into(field)
                };
                let mut document = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_properties::document>,
                        String,
                    >(row, "document")?;
                    <String as Into<String>>::into(field)
                };
                let mut pattern = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_properties::pattern>,
                        String,
                    >(row, "pattern")?;
                    <String as Into<String>>::into(field)
                };
                let mut rel = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_properties::rel>,
                        String,
                    >(row, "rel")?;
                    <String as Into<String>>::into(field)
                };
                let mut value = {
                    let field = diesel::row::NamedRow::get::<
                        diesel::dsl::SqlTypeOf<schema::meta_properties::value>,
                        Option<String>,
                    >(row, "value")?;
                    <Option<String> as Into<Option<String>>>::into(field)
                };
                deserialize::Result::Ok(Self {
                    id: id,
                    document: document,
                    pattern: pattern,
                    rel: rel,
                    value: value,
                })
            }
        }
        fn _check_field_compatibility()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::pattern>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::rel>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::value>,
                Pg,
            >,
        {}
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::associations::{HasTable, Identifiable};
        impl HasTable for MetaProperty {
            type Table = schema::meta_properties::table;
            fn table() -> Self::Table {
                schema::meta_properties::table
            }
        }
        impl<'ident> Identifiable for &'ident MetaProperty {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
        impl<'ident> Identifiable for &'_ &'ident MetaProperty {
            type Id = (&'ident Uuid);
            fn id(self) -> Self::Id {
                (&self.id)
            }
        }
    };
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::expression::Selectable;
        impl<__DB: diesel::backend::Backend> Selectable<__DB> for MetaProperty {
            type SelectExpression = (
                schema::meta_properties::id,
                schema::meta_properties::document,
                schema::meta_properties::pattern,
                schema::meta_properties::rel,
                schema::meta_properties::value,
            );
            fn construct_selection() -> Self::SelectExpression {
                (
                    schema::meta_properties::id,
                    schema::meta_properties::document,
                    schema::meta_properties::pattern,
                    schema::meta_properties::rel,
                    schema::meta_properties::value,
                )
            }
        }
        fn _check_field_compatibility<__DB: diesel::backend::Backend>()
        where
            Uuid: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::id>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::document>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::pattern>,
                Pg,
            >,
            String: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::rel>,
                Pg,
            >,
            Option<
                String,
            >: diesel::deserialize::FromSqlRow<
                diesel::dsl::SqlTypeOf<schema::meta_properties::value>,
                Pg,
            >,
        {}
    };
    /// An [`Insertable`] version of [`MetaLinkTitle`].
    #[diesel(table_name = schema::meta_properties)]
    #[diesel(check_for_backend(Pg))]
    pub struct MetaPropertyInsert {
        /// The document the record is valid for.
        pub document: String,
        /// The [PostgreSQL ILIKE pattern] to match the search term against for the record to be valid.
        ///
        /// [PostgreSQL ILIKE pattern]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-LIKE
        pub pattern: String,
        /// The relationship the property establishes between the [`MetaSubject`] and the [`MetaProperty::value`].
        pub rel: String,
        /// The value that the property has.
        pub value: Option<String>,
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for MetaPropertyInsert {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field4_finish(
                f,
                "MetaPropertyInsert",
                "document",
                &self.document,
                "pattern",
                &self.pattern,
                "rel",
                &self.rel,
                "value",
                &&self.value,
            )
        }
    }
    #[allow(unused_imports)]
    const _: () = {
        use diesel;
        use diesel::insertable::Insertable;
        use diesel::internal::derives::insertable::UndecoratedInsertRecord;
        use diesel::prelude::*;
        #[allow(unused_qualifications)]
        impl Insertable<schema::meta_properties::table> for MetaPropertyInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::pattern, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::rel, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::value, String>,
                >,
            ) as Insertable<schema::meta_properties::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::document, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::pattern, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::rel, String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::value, String>,
                >,
            ) as Insertable<schema::meta_properties::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_properties::document.eq(self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_properties::pattern.eq(self.pattern),
                    ),
                    std::option::Option::Some(schema::meta_properties::rel.eq(self.rel)),
                    self.value.map(|x| schema::meta_properties::value.eq(x)),
                )
                    .values()
            }
        }
        #[allow(unused_qualifications)]
        impl<'insert> Insertable<schema::meta_properties::table>
        for &'insert MetaPropertyInsert {
            type Values = <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::rel, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::value, &'insert String>,
                >,
            ) as Insertable<schema::meta_properties::table>>::Values;
            fn values(
                self,
            ) -> <(
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::document, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::pattern, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::rel, &'insert String>,
                >,
                std::option::Option<
                    diesel::dsl::Eq<schema::meta_properties::value, &'insert String>,
                >,
            ) as Insertable<schema::meta_properties::table>>::Values {
                (
                    std::option::Option::Some(
                        schema::meta_properties::document.eq(&self.document),
                    ),
                    std::option::Option::Some(
                        schema::meta_properties::pattern.eq(&self.pattern),
                    ),
                    std::option::Option::Some(
                        schema::meta_properties::rel.eq(&self.rel),
                    ),
                    self.value.as_ref().map(|x| schema::meta_properties::value.eq(x)),
                )
                    .values()
            }
        }
        impl UndecoratedInsertRecord<schema::meta_properties::table>
        for MetaPropertyInsert {}
    };
    /// Allow [`diesel::sql_types::Text`] values to be parsed as [`MediaTypeDatabase`].
    impl<DB> FromSql<diesel::sql_types::Text, DB> for MediaTypeDatabase
    where
        DB: diesel::backend::Backend,
        String: FromSql<diesel::sql_types::Text, DB>,
    {
        fn from_sql(
            bytes: <DB as diesel::backend::Backend>::RawValue<'_>,
        ) -> diesel::deserialize::Result<Self> {
            {
                let lvl = ::log::Level::Trace;
                if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() {
                    ::log::__private_api::log(
                        format_args!("Reading TEXT from the database..."),
                        lvl,
                        &(
                            "acrate_database::meta",
                            "acrate_database::meta",
                            ::log::__private_api::loc(),
                        ),
                        (),
                    );
                }
            };
            let s = <String as FromSql<diesel::sql_types::Text, DB>>::from_sql(bytes)?;
            {
                let lvl = ::log::Level::Trace;
                if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() {
                    ::log::__private_api::log(
                        format_args!("Attempting to parse as a media type: {0:?}", s),
                        lvl,
                        &(
                            "acrate_database::meta",
                            "acrate_database::meta",
                            ::log::__private_api::loc(),
                        ),
                        (),
                    );
                }
            };
            let mt: MediaTypeBuf = s.parse()?;
            {
                let lvl = ::log::Level::Trace;
                if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() {
                    ::log::__private_api::log(
                        format_args!("Successfully parsed media type: {0:?}", mt),
                        lvl,
                        &(
                            "acrate_database::meta",
                            "acrate_database::meta",
                            ::log::__private_api::loc(),
                        ),
                        (),
                    );
                }
            };
            Ok(Self(mt))
        }
    }
    /// Allow [`diesel::sql_types::Text`] values to be written to with [`MediaTypeDatabase`].
    impl<DB> ToSql<diesel::sql_types::Text, DB> for MediaTypeDatabase
    where
        DB: diesel::backend::Backend,
        str: ToSql<diesel::sql_types::Text, DB>,
    {
        fn to_sql<'b>(
            &'b self,
            out: &mut Output<'b, '_, DB>,
        ) -> diesel::serialize::Result {
            {
                let lvl = ::log::Level::Trace;
                if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() {
                    ::log::__private_api::log(
                        format_args!(
                            "Getting the essence of a media type to prepare for serialization...",
                        ),
                        lvl,
                        &(
                            "acrate_database::meta",
                            "acrate_database::meta",
                            ::log::__private_api::loc(),
                        ),
                        (),
                    );
                }
            };
            let mt = self.0.as_str();
            {
                let lvl = ::log::Level::Trace;
                if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() {
                    ::log::__private_api::log(
                        format_args!("Serializing media type as TEXT: {0:?}", mt),
                        lvl,
                        &(
                            "acrate_database::meta",
                            "acrate_database::meta",
                            ::log::__private_api::loc(),
                        ),
                        (),
                    );
                }
            };
            <str as ToSql<diesel::sql_types::Text, DB>>::to_sql(mt, out)
        }
    }
    impl MetaSubject {
        /// Synchronously query the records matching the given document and resource.
        pub fn query_matching(
            conn: &mut PgConnection,
            doc: &str,
            resource: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel::RunQueryDsl;
            use schema::meta_subjects::dsl::*;
            let document_is_equal = document.eq(doc);
            let resource_matches_pattern = resource
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_subjects
                .filter(document_is_equal)
                .filter(resource_matches_pattern)
                .select(Self::as_select())
                .load(conn)
        }
        /// Asynchronously query the records matching the given document and resource.
        pub async fn aquery_matching(
            conn: &mut AsyncPgConnection,
            doc: &str,
            resource: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel_async::RunQueryDsl;
            use schema::meta_subjects::dsl::*;
            let document_is_equal = document.eq(doc);
            let resource_matches_pattern = resource
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_subjects
                .filter(document_is_equal)
                .filter(resource_matches_pattern)
                .select(Self::as_select())
                .load(conn)
                .await
        }
    }
    impl MetaSubjectInsert {
        /// Syncronously insert the record into the table, returning the full inserted record.
        pub fn insert(self, conn: &mut PgConnection) -> QueryResult<MetaSubject> {
            use diesel::RunQueryDsl;
            use schema::meta_subjects::dsl::*;
            insert_into(meta_subjects).values(self).get_result(conn)
        }
        /// Asyncronously insert the record into the table, returning the full inserted record.
        pub async fn ainsert(
            self,
            conn: &mut AsyncPgConnection,
        ) -> QueryResult<MetaSubject> {
            use diesel_async::RunQueryDsl;
            use schema::meta_subjects::dsl::*;
            insert_into(meta_subjects).values(self).get_result(conn).await
        }
    }
    impl MetaAlias {
        /// Synchronously query the records matching the given document and resource.
        pub fn query_matching(
            conn: &mut PgConnection,
            doc: &str,
            subject: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel::RunQueryDsl;
            use schema::meta_aliases::dsl::*;
            let document_is_equal = document.eq(doc);
            let subject_matches_pattern = subject
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_aliases
                .filter(document_is_equal)
                .filter(subject_matches_pattern)
                .select(Self::as_select())
                .load(conn)
        }
        /// Asynchronously query the records matching the given document and resource.
        pub async fn aquery_matching(
            conn: &mut AsyncPgConnection,
            doc: &str,
            subject: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel_async::RunQueryDsl;
            use schema::meta_aliases::dsl::*;
            let document_is_equal = document.eq(doc);
            let subject_matches_pattern = subject
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_aliases
                .filter(document_is_equal)
                .filter(subject_matches_pattern)
                .select(Self::as_select())
                .load(conn)
                .await
        }
    }
    impl MetaAliasInsert {
        /// Syncronously insert the record into the table, returning the full inserted record.
        pub fn insert(self, conn: &mut PgConnection) -> QueryResult<MetaAlias> {
            use diesel::RunQueryDsl;
            use schema::meta_aliases::dsl::*;
            insert_into(meta_aliases).values(self).get_result(conn)
        }
        /// Asyncronously insert the record into the table, returning the full inserted record.
        pub async fn ainsert(
            self,
            conn: &mut AsyncPgConnection,
        ) -> QueryResult<MetaAlias> {
            use diesel_async::RunQueryDsl;
            use schema::meta_aliases::dsl::*;
            insert_into(meta_aliases).values(self).get_result(conn).await
        }
    }
    impl MetaLink {
        /// Synchronously query the records matching the given document and resource.
        pub async fn query_matching(
            conn: &mut PgConnection,
            doc: &str,
            subject: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel::RunQueryDsl;
            use schema::meta_links::dsl::*;
            let document_is_equal = document.eq(doc);
            let subject_matches_pattern = subject
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_links
                .filter(document_is_equal)
                .filter(subject_matches_pattern)
                .select(Self::as_select())
                .load(conn)
        }
        /// Asynchronously query the records matching the given document and resource.
        pub async fn aquery_matching(
            conn: &mut AsyncPgConnection,
            doc: &str,
            subject: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel_async::RunQueryDsl;
            use schema::meta_links::dsl::*;
            let document_is_equal = document.eq(doc);
            let subject_matches_pattern = subject
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_links
                .filter(document_is_equal)
                .filter(subject_matches_pattern)
                .select(Self::as_select())
                .load(conn)
                .await
        }
    }
    impl MetaLinkInsert {
        /// Syncronously insert the record into the table, returning the full inserted record.
        pub fn insert(self, conn: &mut PgConnection) -> QueryResult<MetaLink> {
            use diesel::RunQueryDsl;
            use schema::meta_links::dsl::*;
            insert_into(meta_links).values(self).get_result(conn)
        }
        /// Asyncronously insert the record into the table, returning the full inserted record.
        pub async fn ainsert(
            self,
            conn: &mut AsyncPgConnection,
        ) -> QueryResult<MetaLink> {
            use diesel_async::RunQueryDsl;
            use schema::meta_links::dsl::*;
            insert_into(meta_links).values(self).get_result(conn).await
        }
    }
    impl MetaLinkProperty {
        /// Synchronously query the records belonging to the given [`MetaLink`]s.
        pub fn query_by_link(
            conn: &mut PgConnection,
            links: &[MetaLink],
        ) -> QueryResult<Vec<Self>> {
            use diesel::RunQueryDsl;
            Self::belonging_to(links).load(conn)
        }
        /// Asynchronously query the records belonging to the given [`MetaLink`]s.
        pub async fn aquery_by_link(
            conn: &mut AsyncPgConnection,
            links: &[MetaLink],
        ) -> QueryResult<Vec<Self>> {
            use diesel_async::RunQueryDsl;
            Self::belonging_to(links).load(conn).await
        }
    }
    impl MetaLinkPropertyInsert {
        /// Syncronously insert the record into the table, returning the full inserted record.
        pub fn insert(self, conn: &mut PgConnection) -> QueryResult<MetaLinkProperty> {
            use diesel::RunQueryDsl;
            use schema::meta_link_properties::dsl::*;
            insert_into(meta_link_properties).values(self).get_result(conn)
        }
        /// Asyncronously insert the record into the table, returning the full inserted record.
        pub async fn ainsert(
            self,
            conn: &mut AsyncPgConnection,
        ) -> QueryResult<MetaLinkProperty> {
            use diesel_async::RunQueryDsl;
            use schema::meta_link_properties::dsl::*;
            insert_into(meta_link_properties).values(self).get_result(conn).await
        }
    }
    impl MetaLinkTitle {
        /// Synchronously query the records belonging to the given [`MetaLink`]s.
        pub fn query_by_link(
            conn: &mut PgConnection,
            links: &[MetaLink],
        ) -> QueryResult<Vec<Self>> {
            use diesel::RunQueryDsl;
            Self::belonging_to(links).load(conn)
        }
        /// Asynchronously query the records belonging to the given [`MetaLink`]s.
        pub async fn aquery_by_link(
            conn: &mut AsyncPgConnection,
            links: &[MetaLink],
        ) -> QueryResult<Vec<Self>> {
            use diesel_async::RunQueryDsl;
            Self::belonging_to(links).load(conn).await
        }
    }
    impl MetaLinkTitleInsert {
        /// Syncronously insert the record into the table, returning the full inserted record.
        pub fn insert(self, conn: &mut PgConnection) -> QueryResult<MetaLinkTitle> {
            use diesel::RunQueryDsl;
            use schema::meta_link_titles::dsl::*;
            insert_into(meta_link_titles).values(self).get_result(conn)
        }
        /// Asyncronously insert the record into the table, returning the full inserted record.
        pub async fn ainsert(
            self,
            conn: &mut AsyncPgConnection,
        ) -> QueryResult<MetaLinkTitle> {
            use diesel_async::RunQueryDsl;
            use schema::meta_link_titles::dsl::*;
            insert_into(meta_link_titles).values(self).get_result(conn).await
        }
    }
    impl MetaProperty {
        /// Synchronously query the records matching the given document and resource.
        pub fn query_matching(
            conn: &mut PgConnection,
            doc: &str,
            subject: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel::RunQueryDsl;
            use schema::meta_properties::dsl::*;
            let document_is_equal = document.eq(doc);
            let subject_matches_pattern = subject
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_properties
                .filter(document_is_equal)
                .filter(subject_matches_pattern)
                .select(Self::as_select())
                .load(conn)
        }
        /// Asynchronously query the records matching the given document and resource.
        pub async fn aquery_matching(
            conn: &mut AsyncPgConnection,
            doc: &str,
            subject: &str,
        ) -> QueryResult<Vec<Self>> {
            use diesel::QueryDsl;
            use diesel_async::RunQueryDsl;
            use schema::meta_properties::dsl::*;
            let document_is_equal = document.eq(doc);
            let subject_matches_pattern = subject
                .into_sql::<diesel::sql_types::Text>()
                .ilike(pattern);
            meta_properties
                .filter(document_is_equal)
                .filter(subject_matches_pattern)
                .select(Self::as_select())
                .load(conn)
                .await
        }
    }
    impl ToInserted<schema::meta_properties::table, MetaProperty>
    for MetaPropertyInsert {}
}
mod traits {
    use diesel::{Insertable, PgConnection, QueryResult, Table};
    use diesel::query_builder::QueryId;
    use diesel_async::AsyncPgConnection;
    pub trait ToInserted<Tbl, Inserted>
    where
        Self: Insertable<Tbl> + Sized,
        Tbl: Table + QueryId + Send,
    {
        /// Syncronously insert the record into the table, returning the full inserted record.
        fn to_inserted(self, conn: &mut PgConnection) -> QueryResult<Inserted> {
            use diesel::RunQueryDsl;
            self.insert_into(Tbl).get_result::<Inserted>(conn)
        }
        /// Asyncronously insert the record into the table, returning the full inserted record.
        async fn to_inserted_async(
            self,
            conn: &mut AsyncPgConnection,
        ) -> QueryResult<Inserted> {
            use diesel_async::RunQueryDsl;
            self.insert_into(Tbl).get_result::<Inserted>(conn).await
        }
    }
}
pub use diesel;
pub use diesel_async;