Enum ColumnType

pub enum ColumnType {
    Char(Option<u32>),
    String(Option<u32>),
    Text,
    TinyInteger,
    SmallInteger,
    Integer,
    BigInteger,
    TinyUnsigned,
    SmallUnsigned,
    Unsigned,
    BigUnsigned,
    Float,
    Double,
    Decimal(Option<(u32, u32)>),
    DateTime,
    Timestamp,
    TimestampWithTimeZone,
    Time,
    Date,
    Binary,
    TinyBinary,
    MediumBinary,
    LongBinary,
    Boolean,
    Money(Option<(u32, u32)>),
    Json,
    JsonBinary,
    Custom(String),
    Uuid,
    Enum {
        name: Arc<dyn Iden>,
        variants: Vec<Arc<dyn Iden>>,
    },
    Array(Arc<ColumnType>),
}

The type of column as defined in the SQL format

Variants

Char(Option<u32>)

CHAR type of specified fixed length

String(Option<u32>)

STRING type for variable string length

Text

TEXT type used for large pieces of string data and stored out of row in case size is too big

TinyInteger

TINYINT useful for storing one byte of data (range of 0-255)

SmallInteger

SMALLINT data type stores small whole numbers that range from –32,767 to 32,767

Integer

INTEGER data types hold numbers that are whole, or without a decimal point

BigInteger

BIGINT is a 64-bit representation of an integer taking up 8 bytes of storage and ranging from -2^63 (-9,223,372,036,854,775,808) to 2^63 (9,223,372,036,854,775,807).

TinyUnsigned

TINYINT UNSIGNED data type

SmallUnsigned

SMALLINT UNSIGNED data type

Unsigned

INTEGER UNSIGNED data type

BigUnsigned

BIGINT UNSIGNED data type

Float

FLOAT an approximate-number data type, where values range cannot be represented exactly.

Double

DOUBLE is a normal-size floating point number where the total number of digits is specified in size.

Decimal(Option<(u32, u32)>)

DECIMAL type store numbers that have fixed precision and scale

DateTime

DATETIME type is used for values that contain both date and time parts.

Timestamp

TIMESTAMP is a temporal data type that holds the combination of date and time.

TimestampWithTimeZone

TIMESTAMP WITH TIME ZONE (or TIMESTAMPTZ) data type stores 8-byte date values that include timestamp and time zone information in UTC format.

Time

TIME data type defines a time of a day based on 24-hour clock

Date

DATE data type stores the calendar date

Binary

BINARY data types contain byte strings—a sequence of octets or bytes.

TinyBinary

Tiny Binary

MediumBinary

Medium Binary

LongBinary

Long Binary

Boolean

BOOLEAN is the result of a comparison operator

Money(Option<(u32, u32)>)

MONEY data type handles monetary data

Json

JSON represents the JavaScript Object Notation type

JsonBinary

JSON binary format is structured in the way that permits the server to search for values within the JSON document directly by key or array index, which is very fast.

Custom(String)

A custom implementation of a data type

Uuid

A Universally Unique IDentifier that is specified in RFC 4122

Enum

ENUM data type with name and variants

Fields

name: Arc<dyn Iden>

Name of enum

variants: Vec<Arc<dyn Iden>>

Variants of enum

Array(Arc<ColumnType>)

Array of a specific data type (PostgreSQL only)

Implementations

impl ColumnType

pub fn def(self) -> ColumnDef

instantiate a new ColumnDef

Trait Implementations

impl Clone for ColumnType

fn clone(&self) -> ColumnType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnType

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

Formats the value using the given formatter.

impl From<ColumnType> for ColumnType

fn from(column_type: ColumnType) -> ColumnType

Converts to this type from the input type.

impl From<ColumnType> for ColumnType

fn from(column_type: ColumnType) -> ColumnType

Converts to this type from the input type.

impl PartialEq for ColumnType

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

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

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

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