Struct mz_transform::notice::IndexTooWideForLiteralConstraints

pub struct IndexTooWideForLiteralConstraints {
    pub index_id: GlobalId,
    pub index_key: Vec<MirScalarExpr>,
    pub usable_subset: Vec<MirScalarExpr>,
    pub literal_values: Vec<Row>,
    pub index_on_id: GlobalId,
    pub recommended_key: Vec<MirScalarExpr>,
}

An index could be used for some literal constraints if the index included only a subset of its columns.

Fields

index_id: GlobalId

The id of the index.

index_key: Vec<MirScalarExpr>

The key of the index.

usable_subset: Vec<MirScalarExpr>

A subset of the index keys. If the index were only on these keys, then it could have been used for a lookup.

literal_values: Vec<Row>

Literal values that we would have looked up in the index, if it were on usable_subset.

index_on_id: GlobalId

The id of the object that the index is on.

recommended_key: Vec<MirScalarExpr>

Our recommendation for what key should a new index have. Note that this might include more columns than usable_subset.

Trait Implementations

impl Clone for IndexTooWideForLiteralConstraints

fn clone(&self) -> IndexTooWideForLiteralConstraints

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IndexTooWideForLiteralConstraints

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

Formats the value using the given formatter.

impl From<IndexTooWideForLiteralConstraints> for RawOptimizerNotice

fn from(value: IndexTooWideForLiteralConstraints) -> Self

Converts to this type from the input type.

impl Hash for IndexTooWideForLiteralConstraints

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl OptimizerNoticeApi for IndexTooWideForLiteralConstraints

fn dependencies(&self) -> BTreeSet<GlobalId>

See OptimizerNoticeApi::dependencies.

fn fmt_message( &self, f: &mut Formatter<'_>, humanizer: &dyn ExprHumanizer, redacted: bool, ) -> Result

Format the text for the optionally redacted OptimizerNotice::message value for this notice.

fn fmt_hint( &self, f: &mut Formatter<'_>, humanizer: &dyn ExprHumanizer, redacted: bool, ) -> Result

Format the text for the optionally redacted OptimizerNotice::hint value for this notice.

fn fmt_action( &self, f: &mut Formatter<'_>, humanizer: &dyn ExprHumanizer, redacted: bool, ) -> Result

Format the text for the optionally redacted OptimizerNotice::action value for this notice.

fn action_kind(&self, humanizer: &dyn ExprHumanizer) -> ActionKind

The kind of action suggested by this notice.

fn message<'a>( &'a self, humanizer: &'a dyn ExprHumanizer, redacted: bool, ) -> HumanizedMessage<'a, Self>

Return a thunk that will render the optionally redacted OptimizerNotice::message value for this notice.

fn hint<'a>( &'a self, humanizer: &'a dyn ExprHumanizer, redacted: bool, ) -> HumanizedHint<'a, Self>

Return a thunk that will render the optionally redacted OptimizerNotice::hint value for this notice.

fn action<'a>( &'a self, humanizer: &'a dyn ExprHumanizer, redacted: bool, ) -> HumanizedAction<'a, Self>

Return a thunk that will render the optionally redacted OptimizerNotice::action value for this notice.

impl PartialEq for IndexTooWideForLiteralConstraints

fn eq(&self, other: &IndexTooWideForLiteralConstraints) -> 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 Eq for IndexTooWideForLiteralConstraints

impl StructuralPartialEq for IndexTooWideForLiteralConstraints