drizzle 0.1.12

#[doc(hidden)]
macro_rules! drizzle_builder_join_impl {
    () => {
        drizzle_builder_join_impl!(natural, drizzle_core::AfterJoin);
        drizzle_builder_join_impl!(natural_left, drizzle_core::AfterLeftJoin);
        drizzle_builder_join_impl!(left, drizzle_core::AfterLeftJoin);
        drizzle_builder_join_impl!(left_outer, drizzle_core::AfterLeftJoin);
        drizzle_builder_join_impl!(natural_left_outer, drizzle_core::AfterLeftJoin);
        drizzle_builder_join_impl!(natural_right, drizzle_core::AfterRightJoin);
        drizzle_builder_join_impl!(right, drizzle_core::AfterRightJoin);
        drizzle_builder_join_impl!(right_outer, drizzle_core::AfterRightJoin);
        drizzle_builder_join_impl!(natural_right_outer, drizzle_core::AfterRightJoin);
        drizzle_builder_join_impl!(natural_full, drizzle_core::AfterFullJoin);
        drizzle_builder_join_impl!(full, drizzle_core::AfterFullJoin);
        drizzle_builder_join_impl!(full_outer, drizzle_core::AfterFullJoin);
        drizzle_builder_join_impl!(natural_full_outer, drizzle_core::AfterFullJoin);
        drizzle_builder_join_impl!(inner, drizzle_core::AfterJoin);
        drizzle_builder_join_impl!(cross, drizzle_core::AfterJoin);
    };
    ($type:ident, $join_trait:path) => {
        paste::paste! {
            pub fn [<$type _join>]<J: drizzle_sqlite::helpers::JoinArg<'a, T>>(
                self,
                arg: J,
            ) -> DrizzleBuilder<
                'd,
                Runner,
                Schema,
                SelectBuilder<'a, Schema, SelectJoinSet, J::JoinedTable, <M as drizzle_core::ScopePush<J::JoinedTable>>::Out, <M as $join_trait<R, J::JoinedTable>>::NewRow, G>,
                SelectJoinSet,
            >
            where
                M: $join_trait<R, J::JoinedTable> + drizzle_core::ScopePush<J::JoinedTable>,
            {
                let builder = self.builder.[<$type _join>](arg);
                DrizzleBuilder {
                    runner: self.runner,
                    builder,
                    state: PhantomData,
                }
            }
        }
    };
}

#[doc(hidden)]
macro_rules! drizzle_pg_builder_join_impl {
    () => {
        drizzle_pg_builder_join_impl!(natural, drizzle_core::AfterJoin);
        drizzle_pg_builder_join_impl!(natural_left, drizzle_core::AfterLeftJoin);
        drizzle_pg_builder_join_impl!(left, drizzle_core::AfterLeftJoin);
        drizzle_pg_builder_join_impl!(left_outer, drizzle_core::AfterLeftJoin);
        drizzle_pg_builder_join_impl!(natural_left_outer, drizzle_core::AfterLeftJoin);
        drizzle_pg_builder_join_impl!(natural_right, drizzle_core::AfterRightJoin);
        drizzle_pg_builder_join_impl!(right, drizzle_core::AfterRightJoin);
        drizzle_pg_builder_join_impl!(right_outer, drizzle_core::AfterRightJoin);
        drizzle_pg_builder_join_impl!(natural_right_outer, drizzle_core::AfterRightJoin);
        drizzle_pg_builder_join_impl!(natural_full, drizzle_core::AfterFullJoin);
        drizzle_pg_builder_join_impl!(full, drizzle_core::AfterFullJoin);
        drizzle_pg_builder_join_impl!(full_outer, drizzle_core::AfterFullJoin);
        drizzle_pg_builder_join_impl!(natural_full_outer, drizzle_core::AfterFullJoin);
        drizzle_pg_builder_join_impl!(inner, drizzle_core::AfterJoin);
        drizzle_pg_builder_join_impl!(cross, drizzle_core::AfterJoin);
    };
    ($type:ident, $join_trait:path) => {
        paste::paste! {
            pub fn [<$type _join>]<J: drizzle_postgres::helpers::JoinArg<'a, T>>(
                self,
                arg: J,
            ) -> DrizzleBuilder<
                'd,
                Runner,
                Schema,
                SelectBuilder<'a, Schema, SelectJoinSet, J::JoinedTable, <M as drizzle_core::ScopePush<J::JoinedTable>>::Out, <M as $join_trait<R, J::JoinedTable>>::NewRow, G>,
                SelectJoinSet,
            >
            where
                M: $join_trait<R, J::JoinedTable> + drizzle_core::ScopePush<J::JoinedTable>,
            {
                let builder = self.builder.[<$type _join>](arg);
                DrizzleBuilder {
                    runner: self.runner,
                    builder,
                    state: PhantomData,
                }
            }
        }
    };
}

#[doc(hidden)]
macro_rules! drizzle_pg_builder_join_using_impl {
    () => {
        drizzle_pg_builder_join_using_impl!(left, drizzle_core::AfterLeftJoin);
        drizzle_pg_builder_join_using_impl!(left_outer, drizzle_core::AfterLeftJoin);
        drizzle_pg_builder_join_using_impl!(right, drizzle_core::AfterRightJoin);
        drizzle_pg_builder_join_using_impl!(right_outer, drizzle_core::AfterRightJoin);
        drizzle_pg_builder_join_using_impl!(full, drizzle_core::AfterFullJoin);
        drizzle_pg_builder_join_using_impl!(full_outer, drizzle_core::AfterFullJoin);
        drizzle_pg_builder_join_using_impl!(inner, drizzle_core::AfterJoin);

        /// JOIN USING clause (plain JOIN).
        pub fn join_using<U: drizzle_postgres::traits::PostgresTable<'a>>(
            self,
            table: U,
            columns: impl drizzle_core::ToSQL<'a, drizzle_postgres::values::PostgresValue<'a>>,
        ) -> DrizzleBuilder<
            'd,
            Runner,
            Schema,
            SelectBuilder<
                'a,
                Schema,
                SelectJoinSet,
                U,
                <M as drizzle_core::ScopePush<U>>::Out,
                <M as drizzle_core::AfterJoin<R, U>>::NewRow,
                G,
            >,
            SelectJoinSet,
        >
        where
            M: drizzle_core::AfterJoin<R, U> + drizzle_core::ScopePush<U>,
        {
            let builder = self.builder.join_using(table, columns);
            DrizzleBuilder {
                runner: self.runner,
                builder,
                state: PhantomData,
            }
        }
    };
    ($type:ident, $join_trait:path) => {
        paste::paste! {
            pub fn [<$type _join_using>]<U: drizzle_postgres::traits::PostgresTable<'a>>(
                self,
                table: U,
                columns: impl drizzle_core::ToSQL<'a, drizzle_postgres::values::PostgresValue<'a>>,
            ) -> DrizzleBuilder<
                'd,
                Runner,
                Schema,
                SelectBuilder<
                    'a,
                    Schema,
                    SelectJoinSet,
                    U,
                    <M as drizzle_core::ScopePush<U>>::Out,
                    <M as $join_trait<R, U>>::NewRow,
                    G,
                >,
                SelectJoinSet,
            >
            where
                M: $join_trait<R, U> + drizzle_core::ScopePush<U>,
            {
                let builder = self.builder.[<$type _join_using>](table, columns);
                DrizzleBuilder {
                    runner: self.runner,
                    builder,
                    state: PhantomData,
                }
            }
        }
    };
}

#[doc(hidden)]
macro_rules! transaction_builder_join_impl {
    ($query_lt:lifetime; $($lifetimes:lifetime),*) => {
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, natural, drizzle_core::AfterJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, natural_left, drizzle_core::AfterLeftJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, left, drizzle_core::AfterLeftJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, left_outer, drizzle_core::AfterLeftJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, natural_left_outer, drizzle_core::AfterLeftJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, natural_right, drizzle_core::AfterRightJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, right, drizzle_core::AfterRightJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, right_outer, drizzle_core::AfterRightJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, natural_right_outer, drizzle_core::AfterRightJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, natural_full, drizzle_core::AfterFullJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, full, drizzle_core::AfterFullJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, full_outer, drizzle_core::AfterFullJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, natural_full_outer, drizzle_core::AfterFullJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, inner, drizzle_core::AfterJoin);
        transaction_builder_join_impl!($query_lt; $($lifetimes),*, cross, drizzle_core::AfterJoin);
    };
    ($query_lt:lifetime; $($lifetimes:lifetime),*, $type:ident, $join_trait:path) => {
        paste::paste! {
            pub fn [<$type _join>]<J: drizzle_sqlite::helpers::JoinArg<$query_lt, T>>(
                self,
                arg: J,
            ) -> TransactionBuilder<
                $($lifetimes,)*
                Schema,
                SelectBuilder<$query_lt, Schema, SelectJoinSet, J::JoinedTable, <M as drizzle_core::ScopePush<J::JoinedTable>>::Out, <M as $join_trait<R, J::JoinedTable>>::NewRow, G>,
                SelectJoinSet,
            >
            where
                M: $join_trait<R, J::JoinedTable> + drizzle_core::ScopePush<J::JoinedTable>,
            {
                let builder = self.builder.[<$type _join>](arg);
                TransactionBuilder {
                    runner: self.runner,
                    builder,
                    state: PhantomData,
                }
            }
        }
    };
}

#[doc(hidden)]
macro_rules! sqlite_transaction_constructors {
    ($($conn_lt:lifetime),*) => {
        /// Creates a SELECT query builder within the transaction
        #[cfg(feature = "sqlite")]
        pub fn select<'tx, 'q, T>(
            &'tx self,
            query: T,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            SelectBuilder<'q, Schema, SelectInitial, (), T::Marker>,
            SelectInitial,
        >
        where
            T: ToSQL<'q, SQLiteValue<'q>> + drizzle_core::IntoSelectTarget,
        {
            use drizzle_sqlite::builder::QueryBuilder;

            let builder = QueryBuilder::new::<Schema>().select(query);

            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates a SELECT DISTINCT query builder within the transaction
        #[cfg(feature = "sqlite")]
        pub fn select_distinct<'tx, 'q, T>(
            &'tx self,
            query: T,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            SelectBuilder<'q, Schema, SelectInitial, (), T::Marker>,
            SelectInitial,
        >
        where
            T: ToSQL<'q, SQLiteValue<'q>> + drizzle_core::IntoSelectTarget,
        {
            use drizzle_sqlite::builder::QueryBuilder;

            let builder = QueryBuilder::new::<Schema>().select_distinct(query);

            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates an INSERT query builder within the transaction
        #[cfg(feature = "sqlite")]
        pub fn insert<'tx, 'q, Table>(
            &'tx self,
            table: Table,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            InsertBuilder<'q, Schema, InsertInitial, Table>,
            InsertInitial,
        >
        where
            Table: SQLiteTable<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().insert(table);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates an UPDATE query builder within the transaction
        #[cfg(feature = "sqlite")]
        pub fn update<'tx, 'q, Table>(
            &'tx self,
            table: Table,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            UpdateBuilder<'q, Schema, UpdateInitial, Table>,
            UpdateInitial,
        >
        where
            Table: SQLiteTable<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().update(table);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates a DELETE query builder within the transaction
        #[cfg(feature = "sqlite")]
        pub fn delete<'tx, 'q, T>(
            &'tx self,
            table: T,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            DeleteBuilder<'q, Schema, DeleteInitial, T>,
            DeleteInitial,
        >
        where
            T: SQLiteTable<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().delete(table);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates a query with CTE (Common Table Expression) within the transaction
        #[cfg(feature = "sqlite")]
        pub fn with<'tx, 'q, C>(
            &'tx self,
            cte: &C,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            QueryBuilder<'q, Schema, builder::CTEInit>,
            builder::CTEInit,
        >
        where
            C: builder::CTEDefinition<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().with(cte);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }
    };
}

#[doc(hidden)]
macro_rules! postgres_transaction_constructors {
    ($($conn_lt:lifetime),*) => {
        /// Creates a SELECT query builder within the transaction
        pub fn select<'tx, 'q, T>(
            &'tx self,
            query: T,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            SelectBuilder<'q, Schema, SelectInitial, (), T::Marker>,
            SelectInitial,
        >
        where
            T: ToSQL<'q, PostgresValue<'q>> + drizzle_core::IntoSelectTarget,
        {
            use drizzle_postgres::builder::QueryBuilder;

            let builder = QueryBuilder::new::<Schema>().select(query);

            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates a SELECT DISTINCT query builder within the transaction
        pub fn select_distinct<'tx, 'q, T>(
            &'tx self,
            query: T,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            SelectBuilder<'q, Schema, SelectInitial, (), T::Marker>,
            SelectInitial,
        >
        where
            T: ToSQL<'q, PostgresValue<'q>> + drizzle_core::IntoSelectTarget,
        {
            use drizzle_postgres::builder::QueryBuilder;

            let builder = QueryBuilder::new::<Schema>().select_distinct(query);

            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates an INSERT query builder within the transaction
        pub fn insert<'tx, 'q, Table>(
            &'tx self,
            table: Table,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            InsertBuilder<'q, Schema, InsertInitial, Table>,
            InsertInitial,
        >
        where
            Table: PostgresTable<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().insert(table);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates an UPDATE query builder within the transaction
        pub fn update<'tx, 'q, Table>(
            &'tx self,
            table: Table,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            UpdateBuilder<'q, Schema, UpdateInitial, Table>,
            UpdateInitial,
        >
        where
            Table: PostgresTable<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().update(table);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates a DELETE query builder within the transaction
        pub fn delete<'tx, 'q, T>(
            &'tx self,
            table: T,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            DeleteBuilder<'q, Schema, DeleteInitial, T>,
            DeleteInitial,
        >
        where
            T: PostgresTable<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().delete(table);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }

        /// Creates a query with CTE (Common Table Expression) within the transaction
        pub fn with<'tx, 'q, C>(
            &'tx self,
            cte: &C,
        ) -> TransactionBuilder<
            'tx,
            $($conn_lt,)*
            Schema,
            QueryBuilder<'q, Schema, builder::CTEInit>,
            builder::CTEInit,
        >
        where
            C: builder::CTEDefinition<'q>,
        {
            let builder = QueryBuilder::new::<Schema>().with(cte);
            TransactionBuilder {
                runner: self,
                builder,
                state: PhantomData,
            }
        }
    };
}