Struct mysql::consts::CapabilityFlags

pub struct CapabilityFlags { /* private fields */ }

Client capability flags

Implementations

impl CapabilityFlags

pub const CLIENT_LONG_PASSWORD: CapabilityFlags = Self{ bits: 1,}

Use the improved version of Old Password Authentication. Assumed to be set since 4.1.1.

pub const CLIENT_FOUND_ROWS: CapabilityFlags = Self{ bits: 2,}

Send found rows instead of affected rows in EOF_Packet.

pub const CLIENT_LONG_FLAG: CapabilityFlags = Self{ bits: 4,}

Get all column flags. Longer flags in Protocol::ColumnDefinition320.

Server

Supports longer flags.

Client

Expects longer flags.

pub const CLIENT_CONNECT_WITH_DB: CapabilityFlags = Self{ bits: 8,}

Database (schema) name can be specified on connect in Handshake Response Packet.

Server

Supports schema-name in Handshake Response Packet.

Client

Handshake Response Packet contains a schema-name.

pub const CLIENT_NO_SCHEMA: CapabilityFlags = Self{ bits: 16,}

Don’t allow database.table.column.

pub const CLIENT_COMPRESS: CapabilityFlags = Self{ bits: 32,}

Compression protocol supported.

Server

Supports compression.

Client

Switches to Compression compressed protocol after successful authentication.

pub const CLIENT_ODBC: CapabilityFlags = Self{ bits: 64,}

Special handling of ODBC behavior.

pub const CLIENT_LOCAL_FILES: CapabilityFlags = Self{ bits: 128,}

Can use LOAD DATA LOCAL.

Server

Enables the LOCAL INFILE request of LOAD DATA|XML.

Client

Will handle LOCAL INFILE request.

pub const CLIENT_IGNORE_SPACE: CapabilityFlags = Self{ bits: 256,}

Ignore spaces before ‘(’.

Server

Parser can ignore spaces before ‘(’.

Client

Let the parser ignore spaces before ‘(’.

pub const CLIENT_PROTOCOL_41: CapabilityFlags = Self{ bits: 512,}

pub const CLIENT_INTERACTIVE: CapabilityFlags = Self{ bits: 1024,}

This is an interactive client. Use System_variables::net_wait_timeout versus System_variables::net_interactive_timeout.

Server

Supports interactive and noninteractive clients.

Client

Client is interactive.

pub const CLIENT_SSL: CapabilityFlags = Self{ bits: 2048,}

Use SSL encryption for the session.

Server

Supports SSL

Client

Switch to SSL after sending the capability-flags.

pub const CLIENT_IGNORE_SIGPIPE: CapabilityFlags = Self{ bits: 4096,}

Client only flag. Not used.

Client

Do not issue SIGPIPE if network failures occur (libmysqlclient only).

pub const CLIENT_TRANSACTIONS: CapabilityFlags = Self{ bits: 8192,}

Client knows about transactions.

Server

Can send status flags in OK_Packet / EOF_Packet.

Client

Expects status flags in OK_Packet / EOF_Packet.

Note

This flag is optional in 3.23, but always set by the server since 4.0.

pub const CLIENT_RESERVED: CapabilityFlags = Self{ bits: 16384,}

pub const CLIENT_SECURE_CONNECTION: CapabilityFlags = Self{ bits: 32768,}

pub const CLIENT_MULTI_STATEMENTS: CapabilityFlags = Self{ bits: 65536,}

Enable/disable multi-stmt support. Also sets CLIENT_MULTI_RESULTS. Currently not checked anywhere.

Server

Can handle multiple statements per COM_QUERY and COM_STMT_PREPARE.

Client

May send multiple statements per COM_QUERY and COM_STMT_PREPARE.

pub const CLIENT_MULTI_RESULTS: CapabilityFlags = Self{ bits: 131072,}

Enable/disable multi-results.

Server

Can send multiple resultsets for COM_QUERY. Error if the server needs to send them and client does not support them.

Client

Can handle multiple resultsets for COM_QUERY.

Requires

CLIENT_PROTOCOL_41

pub const CLIENT_PS_MULTI_RESULTS: CapabilityFlags = Self{ bits: 262144,}

Multi-results and OUT parameters in PS-protocol.

Server

Can send multiple resultsets for COM_STMT_EXECUTE.

Client

Can handle multiple resultsets for COM_STMT_EXECUTE.

Requires

CLIENT_PROTOCOL_41

pub const CLIENT_PLUGIN_AUTH: CapabilityFlags = Self{ bits: 524288,}

Client supports plugin authentication.

Server

Sends extra data in Initial Handshake Packet and supports the pluggable authentication protocol.

Client

Supports authentication plugins.

Requires

CLIENT_PROTOCOL_41

pub const CLIENT_CONNECT_ATTRS: CapabilityFlags = Self{ bits: 1048576,}

Client supports connection attributes.

Server

Permits connection attributes in Protocol::HandshakeResponse41.

Client

Sends connection attributes in Protocol::HandshakeResponse41.

pub const CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA: CapabilityFlags = Self{ bits: 2097152,}

Enable authentication response packet to be larger than 255 bytes. When the ability to change default plugin require that the initial password field in the Protocol::HandshakeResponse41 paclet can be of arbitrary size. However, the 4.1 client-server protocol limits the length of the auth-data-field sent from client to server to 255 bytes. The solution is to change the type of the field to a true length encoded string and indicate the protocol change with this client capability flag.

Server

Understands length-encoded integer for auth response data in Protocol::HandshakeResponse41.

Client

Length of auth response data in Protocol::HandshakeResponse41 is a length-encoded integer.

Note

The flag was introduced in 5.6.6, but had the wrong value.

pub const CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS: CapabilityFlags = Self{ bits: 4194304,}

Don’t close the connection for a user account with expired password.

Server

Announces support for expired password extension.

Client

Can handle expired passwords.

pub const CLIENT_SESSION_TRACK: CapabilityFlags = Self{ bits: 8388608,}

Capable of handling server state change information. Its a hint to the server to include the state change information in OK_Packet.

Server

Can set SERVER_SESSION_STATE_CHANGED in the SERVER_STATUS_flags_enum and send Session State Information in a OK_Packet.

Client

Expects the server to send Session State Information in a OK_Packet.

pub const CLIENT_DEPRECATE_EOF: CapabilityFlags = Self{ bits: 16777216,}

Client no longer needs EOF_Packet and will use OK_Packet instead.

Server

Can send OK after a Text Resultset.

Client

Expects an OK_Packet (instead of EOF_Packet) after the resultset rows of a Text Resultset.

Background

To support CLIENT_SESSION_TRACK, additional information must be sent after all successful commands. Although the OK_Packet is extensible, the EOF_Packet is not due to the overlap of its bytes with the content of the Text Resultset Row.

Therefore, the EOF_Packet in the Text Resultset is replaced with an OK_Packet. EOF_Packet is deprecated as of MySQL 5.7.5.

pub const CLIENT_PROGRESS_OBSOLETE: CapabilityFlags = Self{ bits: 536870912,}

Client or server supports progress reports within error packet.

pub const CLIENT_SSL_VERIFY_SERVER_CERT: CapabilityFlags = Self{ bits: 1073741824,}

Verify server certificate. Client only flag.

Deprecated in favor of –ssl-mode.

pub const CLIENT_REMEMBER_OPTIONS: CapabilityFlags = Self{ bits: 2147483648,}

Don’t reset the options after an unsuccessful connect. Client only flag.

pub const fn empty() -> CapabilityFlags

Returns an empty set of flags.

pub const fn all() -> CapabilityFlags

Returns the set containing all flags.

pub const fn bits(&self) -> u32

Returns the raw value of the flags currently stored.

pub const fn from_bits(bits: u32) -> Option<CapabilityFlags>

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

pub const fn from_bits_truncate(bits: u32) -> CapabilityFlags

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

pub const unsafe fn from_bits_unchecked(bits: u32) -> CapabilityFlags

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

Safety

The caller of the bitflags! macro can chose to allow or disallow extra bits for their bitflags type.

The caller of from_bits_unchecked() has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.

pub const fn is_empty(&self) -> bool

Returns true if no flags are currently stored.

pub const fn is_all(&self) -> bool

Returns true if all flags are currently set.

pub const fn intersects(&self, other: CapabilityFlags) -> bool

Returns true if there are flags common to both self and other.

pub const fn contains(&self, other: CapabilityFlags) -> bool

Returns true if all of the flags in other are contained within self.

pub fn insert(&mut self, other: CapabilityFlags)

Inserts the specified flags in-place.

pub fn remove(&mut self, other: CapabilityFlags)

Removes the specified flags in-place.

pub fn toggle(&mut self, other: CapabilityFlags)

Toggles the specified flags in-place.

pub fn set(&mut self, other: CapabilityFlags, value: bool)

Inserts or removes the specified flags depending on the passed value.

pub const fn intersection(self, other: CapabilityFlags) -> CapabilityFlags

Returns the intersection between the flags in self and other.

Specifically, the returned set contains only the flags which are present in both self and other.

This is equivalent to using the & operator (e.g. ops::BitAnd), as in flags & other.

pub const fn union(self, other: CapabilityFlags) -> CapabilityFlags

Returns the union of between the flags in self and other.

Specifically, the returned set contains all flags which are present in either self or other, including any which are present in both (see Self::symmetric_difference if that is undesirable).

This is equivalent to using the | operator (e.g. ops::BitOr), as in flags | other.

pub const fn difference(self, other: CapabilityFlags) -> CapabilityFlags

Returns the difference between the flags in self and other.

Specifically, the returned set contains all flags present in self, except for the ones present in other.

It is also conceptually equivalent to the “bit-clear” operation: flags & !other (and this syntax is also supported).

This is equivalent to using the - operator (e.g. ops::Sub), as in flags - other.

pub const fn symmetric_difference(
    self,
    other: CapabilityFlags
) -> CapabilityFlags

Returns the symmetric difference between the flags in self and other.

Specifically, the returned set contains the flags present which are present in self or other, but that are not present in both. Equivalently, it contains the flags present in exactly one of the sets self and other.

This is equivalent to using the ^ operator (e.g. ops::BitXor), as in flags ^ other.

pub const fn complement(self) -> CapabilityFlags

Returns the complement of this set of flags.

Specifically, the returned set contains all the flags which are not set in self, but which are allowed for this type.

Alternatively, it can be thought of as the set difference between Self::all() and self (e.g. Self::all() - self)

This is equivalent to using the ! operator (e.g. ops::Not), as in !flags.

Trait Implementations

impl Binary for CapabilityFlags

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

Formats the value using the given formatter.

impl BitAnd<CapabilityFlags> for CapabilityFlags

fn bitand(self, other: CapabilityFlags) -> CapabilityFlags

Returns the intersection between the two sets of flags.

type Output = CapabilityFlags

The resulting type after applying the & operator.

impl BitAndAssign<CapabilityFlags> for CapabilityFlags

fn bitand_assign(&mut self, other: CapabilityFlags)

Disables all flags disabled in the set.

impl BitOr<CapabilityFlags> for CapabilityFlags

fn bitor(self, other: CapabilityFlags) -> CapabilityFlags

Returns the union of the two sets of flags.

type Output = CapabilityFlags

The resulting type after applying the | operator.

impl BitOrAssign<CapabilityFlags> for CapabilityFlags

fn bitor_assign(&mut self, other: CapabilityFlags)

Adds the set of flags.

impl BitXor<CapabilityFlags> for CapabilityFlags

fn bitxor(self, other: CapabilityFlags) -> CapabilityFlags

Returns the left flags, but with all the right flags toggled.

type Output = CapabilityFlags

The resulting type after applying the ^ operator.

impl BitXorAssign<CapabilityFlags> for CapabilityFlags

fn bitxor_assign(&mut self, other: CapabilityFlags)

Toggles the set of flags.

impl Clone for CapabilityFlags

fn clone(&self) -> CapabilityFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CapabilityFlags

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

Formats the value using the given formatter.

impl Extend<CapabilityFlags> for CapabilityFlags

fn extend<T>(&mut self, iterator: T)where
    T: IntoIterator<Item = CapabilityFlags>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<CapabilityFlags> for CapabilityFlags

fn from_iter<T>(iterator: T) -> CapabilityFlagswhere
    T: IntoIterator<Item = CapabilityFlags>,

Creates a value from an iterator.

impl Hash for CapabilityFlags

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

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 LowerHex for CapabilityFlags

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

Formats the value using the given formatter.

impl Not for CapabilityFlags

fn not(self) -> CapabilityFlags

Returns the complement of this set of flags.

type Output = CapabilityFlags

The resulting type after applying the ! operator.

impl Octal for CapabilityFlags

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

Formats the value using the given formatter.

impl Ord for CapabilityFlags

fn cmp(&self, other: &CapabilityFlags) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<CapabilityFlags> for CapabilityFlags

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<CapabilityFlags> for CapabilityFlags

fn partial_cmp(&self, other: &CapabilityFlags) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<CapabilityFlags> for CapabilityFlags

fn sub(self, other: CapabilityFlags) -> CapabilityFlags

Returns the set difference of the two sets of flags.

type Output = CapabilityFlags

The resulting type after applying the - operator.

impl SubAssign<CapabilityFlags> for CapabilityFlags

fn sub_assign(&mut self, other: CapabilityFlags)

Disables all flags enabled in the set.

impl UpperHex for CapabilityFlags

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

Formats the value using the given formatter.

impl Copy for CapabilityFlags

impl Eq for CapabilityFlags

impl StructuralEq for CapabilityFlags

impl StructuralPartialEq for CapabilityFlags