Struct sql_schema_describer::postgres::PostgresSchemaExt

source ·

pub struct PostgresSchemaExt {
    pub opclasses: Vec<(IndexColumnId, SQLOperatorClass)>,
    pub indexes: Vec<(IndexId, SqlIndexAlgorithm)>,
    pub expression_indexes: Vec<(TableId, String)>,
    pub index_null_position: HashMap<IndexColumnId, IndexNullPosition>,
    pub constraint_options: HashMap<Constraint, BitFlags<ConstraintOption>>,
    pub table_options: Vec<BTreeMap<String, String>>,
    pub exclude_constraints: Vec<(TableId, String)>,
    pub sequences: Vec<Sequence>,
    /* private fields */
}

Fields§

§opclasses: Vec<(IndexColumnId, SQLOperatorClass)>§indexes: Vec<(IndexId, SqlIndexAlgorithm)>§expression_indexes: Vec<(TableId, String)>§index_null_position: HashMap<IndexColumnId, IndexNullPosition>§constraint_options: HashMap<Constraint, BitFlags<ConstraintOption>>§table_options: Vec<BTreeMap<String, String>>§exclude_constraints: Vec<(TableId, String)>§sequences: Vec<Sequence>

The schema’s sequences.

Struct sql_schema_describer::postgres::PostgresSchemaExt

Fields§

Implementations§

impl PostgresSchemaExt

pub fn index_algorithm(&self, index_id: IndexId) -> SqlIndexAlgorithm

pub fn get_opclass( &self, index_field_id: IndexColumnId ) -> Option<&SQLOperatorClass>

pub fn get_sequence(&self, name: &str) -> Option<(usize, &Sequence)>

pub fn extension_walkers(&self) -> impl Iterator<Item = ExtensionWalker<'_>>

pub fn extension_walker<'a>(&'a self, name: &str) -> Option<ExtensionWalker<'a>>

pub fn push_extension(&mut self, extension: DatabaseExtension)

pub fn get_extension(&self, id: ExtensionId) -> &DatabaseExtension

pub fn clear_extensions(&mut self)

pub fn non_default_null_position(&self, column: IndexColumnWalker<'_>) -> bool

pub fn uses_row_level_ttl(&self, id: TableId) -> bool

pub fn non_default_foreign_key_constraint_deferring( &self, id: ForeignKeyId ) -> bool

pub fn non_default_index_constraint_deferring(&self, id: IndexId) -> bool

pub fn exclude_constraints( &self, table_id: TableId ) -> impl ExactSizeIterator<Item = &str>

pub fn uses_exclude_constraint(&self, id: TableId) -> bool

Trait Implementations§

impl Debug for PostgresSchemaExt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Default for PostgresSchemaExt

fn default() -> PostgresSchemaExt

Auto Trait Implementations§

impl RefUnwindSafe for PostgresSchemaExt

impl Send for PostgresSchemaExt

impl Sync for PostgresSchemaExt

impl Unpin for PostgresSchemaExt

impl UnwindSafe for PostgresSchemaExt

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<Choices> CoproductSubsetter<CNil, HNil> for Choices

type Remainder = Choices

fn subset( self ) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T, U, I> LiftInto<U, I> for Twhere U: LiftFrom<T, I>,

fn lift_into(self) -> U

impl<T> Pipe for Twhere T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> Rwhere Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<Source> Sculptor<HNil, HNil> for Source