From 16e6d6b97a0d5d0b62a3dfd652956d35374cdb96 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <me@steffo.eu>
Date: Tue, 10 Dec 2024 07:14:42 +0100
Subject: [PATCH] `database`: Abstract `insert` functions with
 `impl_to_insert!` macro

---
 acrate_database/src/lib.rs    |     1 +
 acrate_database/src/macros.rs |    24 +
 acrate_database/src/meta.rs   |   147 +-
 expansion.rs                  | 13786 ++++++++++++++++++++++++++++++++
 4 files changed, 13819 insertions(+), 139 deletions(-)
 create mode 100644 acrate_database/src/macros.rs
 create mode 100644 expansion.rs

diff --git a/acrate_database/src/lib.rs b/acrate_database/src/lib.rs
index fe4a7c2..42af5be 100644
--- a/acrate_database/src/lib.rs
+++ b/acrate_database/src/lib.rs
@@ -6,6 +6,7 @@
 mod schema;
 
 pub mod meta;
+mod macros;
 
 pub use diesel;
 pub use diesel_async;
diff --git a/acrate_database/src/macros.rs b/acrate_database/src/macros.rs
new file mode 100644
index 0000000..521df6e
--- /dev/null
+++ b/acrate_database/src/macros.rs
@@ -0,0 +1,24 @@
+/// Implement `to_insert` and `to_inserted_async` for the given `$insert_type`, resulting in the given `$result_type`, adding a record to `$table_type`.
+#[macro_export]
+macro_rules! impl_to_insert {
+    ($insert_type:ty => $table_type:expr => $result_type:ty) => {
+		impl $insert_type {
+			/// Syncronously insert the record into the table, returning the full inserted record.
+			pub fn to_inserted(self, conn: &mut diesel::pg::PgConnection) -> diesel::QueryResult<$result_type> {
+				use diesel::RunQueryDsl;
+				
+				self.insert_into($table_type)
+					.get_result::<$result_type>(conn)
+			}
+			
+			/// Asyncronously insert the record into the table, returning the full inserted record.
+			pub async fn to_inserted_async(self, conn: &mut diesel_async::AsyncPgConnection) -> diesel::QueryResult<$result_type> {
+				use diesel_async::RunQueryDsl;
+				
+				self.insert_into($table_type)
+					.get_result::<$result_type>(conn)
+					.await
+			}
+		}
+	};
+}
diff --git a/acrate_database/src/meta.rs b/acrate_database/src/meta.rs
index 2d014a6..618e301 100644
--- a/acrate_database/src/meta.rs
+++ b/acrate_database/src/meta.rs
@@ -35,8 +35,8 @@ use diesel_async::AsyncPgConnection;
 use mediatype::MediaTypeBuf;
 use uuid::Uuid;
 
-use super::schema;
-
+use crate::schema;
+use crate::impl_to_insert;
 
 /// Wrapper to use [`mime::Mime`] with [`diesel`].
 #[derive(Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression)]
@@ -417,29 +417,6 @@ impl MetaSubject {
 	}
 }
 
-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>> {
@@ -475,29 +452,6 @@ impl MetaAlias {
 	}
 }
 
-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>> {
@@ -533,29 +487,6 @@ impl MetaLink {
 	}
 }
 
-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>> {
@@ -575,29 +506,6 @@ impl MetaLinkProperty {
 	}
 }
 
-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>> {
@@ -617,29 +525,6 @@ impl MetaLinkTitle {
 	}
 }
 
-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>> {
@@ -675,25 +560,9 @@ impl MetaProperty {
 	}
 }
 
-impl MetaPropertyInsert {
-	/// Syncronously insert the record into the table, returning the full inserted record.
-	pub fn insert(self, conn: &mut PgConnection) -> QueryResult<MetaProperty> {
-		use diesel::RunQueryDsl;
-		use schema::meta_properties::dsl::*;
-		
-		insert_into(meta_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<MetaProperty> {
-		use diesel_async::RunQueryDsl;
-		use schema::meta_properties::dsl::*;
-		
-		insert_into(meta_properties)
-			.values(self)
-			.get_result(conn)
-			.await
-	}
-}
+impl_to_insert!(MetaSubjectInsert => schema::meta_subjects::table => MetaSubject);
+impl_to_insert!(MetaAliasInsert => schema::meta_aliases::table => MetaAlias);
+impl_to_insert!(MetaLinkInsert => schema::meta_links::table => MetaLink);
+impl_to_insert!(MetaLinkPropertyInsert => schema::meta_link_properties::table => MetaLinkProperty);
+impl_to_insert!(MetaLinkTitleInsert => schema::meta_link_titles::table => MetaLinkTitle);
+impl_to_insert!(MetaPropertyInsert => schema::meta_properties::table => MetaProperty);
diff --git a/expansion.rs b/expansion.rs
new file mode 100644
index 0000000..bba9caa
--- /dev/null
+++ b/expansion.rs
@@ -0,0 +1,13786 @@
+#![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;