Struct PgIndex 

pub struct PgIndex {

    pub indexrelid: SmolStr,
    pub indrelid: SmolStr,
    pub indnatts: u16,
    pub indnkeyatts: u16,
    pub indisunique: bool,
    pub indnullsnotdistinct: bool,
    pub indisprimary: bool,
    pub indisexclusion: bool,
    pub indimmediate: bool,
    pub indisreplident: bool,
    pub indkey: Vec<u16>,
    pub indcollation: Vec<Option<SmolStr>>,
    pub indclass: Vec<SmolStr>,
    pub indoption: Vec<i16>,
    pub indexprs: Option<SmolStr>,
    pub indpred: Option<SmolStr>,
}

The DDL-only contents of pg_index

Fields

indexrelid: SmolStr

oid (references pg_class.oid) The OID of the pg_class entry for this index

indrelid: SmolStr

oid (references pg_class.oid) The OID of the pg_class entry for the table this index is for

indnatts: u16

int2 The total number of columns in the index (duplicates pg_class.relnatts); this number includes both key and included attributes

indnkeyatts: u16

int2 The number of key columns in the index, not counting any included columns, which are merely stored and do not participate in the index semantics

indisunique: bool

bool If true, this is a unique index

indnullsnotdistinct: bool

bool This value is only used for unique indexes. If false, this unique index will consider null values distinct (so the index can contain multiple null values in a column, the default PostgreSQL behavior). If it is true, it will consider null values to be equal (so the index can only contain one null value in a column).

indisprimary: bool

bool If true, this index represents the primary key of the table (indisunique should always be true when this is true)

indisexclusion: bool

bool If true, this index supports an exclusion constraint

indimmediate: bool

bool If true, the uniqueness check is enforced immediately on insertion (irrelevant if indisunique is not true)

indisreplident: bool

bool If true this index has been chosen as “replica identity” using ALTER TABLE … REPLICA IDENTITY USING INDEX …

indkey: Vec<u16>

int2vector (references pg_attribute.attnum) This is an array of indnatts values that indicate which table columns this index indexes. For example, a value of 1 3 would mean that the first and the third table columns make up the index entries. Key columns come before non-key (included) columns. A zero in this array indicates that the corresponding index attribute is an expression over the table columns, rather than a simple column reference.

indcollation: Vec<Option<SmolStr>>

oidvector (references pg_collation.oid) For each column in the index key (indnkeyatts values), this contains the OID of the collation to use for the index, or zero if the column is not of a collatable data type.

indclass: Vec<SmolStr>

oidvector (references pg_opclass.oid) For each column in the index key (indnkeyatts values), this contains the OID of the operator class to use. See pg_opclass for details.

indoption: Vec<i16>

int2vector This is an array of indnkeyatts values that store per-column flag bits. The meaning of the bits is defined by the index’s access method.

indexprs: Option<SmolStr>

pg_node_tree Expression trees (in nodeToString() representation) for index attributes that are not simple column references. This is a list with one element for each zero entry in indkey. Null if all index attributes are simple references.

indpred: Option<SmolStr>

pg_node_tree Expression tree (in nodeToString() representation) for partial index predicate. Null if not a partial index.

Trait Implementations

impl Clone for PgIndex

fn clone(&self) -> PgIndex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PgIndex

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PgIndex

fn deserialize<__D>( __deserializer: __D, ) -> Result<PgIndex, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PgIndex

fn eq(&self, other: &PgIndex) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PgIndex

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PgIndex

impl StructuralPartialEq for PgIndex