Enum LogicalType 

pub enum LogicalType {
    Any,
    Null,
    Bool,
    Int8,
    Int16,
    Int32,
    Int64,
    Float32,
    Float64,
    String,
    Bytes,
    Date,
    Time,
    Timestamp,
    Duration,
    List(Box<LogicalType>),
    Map {
        key: Box<LogicalType>,
        value: Box<LogicalType>,
    },
    Struct(Vec<(String, LogicalType)>),
    Node,
    Edge,
    Path,
}

Logical type for values in Grafeo.

These types correspond to the GQL/Cypher type system and are used for:

• Schema definitions (column types in node/edge tables)
• Query type checking
• Value coercion rules

Variants

Any

Unknown or any type (used during type inference)

Null

Null type (only value is NULL)

Bool

Boolean type

Int8

8-bit signed integer

Int16

16-bit signed integer

Int32

32-bit signed integer

Int64

64-bit signed integer

Float32

32-bit floating point

Float64

64-bit floating point

String

Variable-length UTF-8 string

Bytes

Binary data

Date

Date (year, month, day)

Time

Time (hour, minute, second, nanosecond)

Timestamp

Timestamp with timezone

Duration

Duration/interval

List(Box<LogicalType>)

Homogeneous list of elements

Map

Key-value map

Fields

key: Box<LogicalType>

Type of map keys (usually String)

value: Box<LogicalType>

Type of map values

Struct(Vec<(String, LogicalType)>)

Struct with named fields

Node

Node reference

Edge

Edge reference

Path

Path (sequence of nodes and edges)

Implementations

impl LogicalType

pub const fn is_numeric(&self) -> bool

Returns true if this type is numeric (integer or floating point).

pub const fn is_integer(&self) -> bool

Returns true if this type is an integer type.

pub const fn is_float(&self) -> bool

Returns true if this type is a floating point type.

pub const fn is_temporal(&self) -> bool

Returns true if this type is a temporal type.

pub const fn is_graph_element(&self) -> bool

Returns true if this type is a graph element type.

pub const fn is_nullable(&self) -> bool

Returns true if this type is nullable (can hold NULL values).

In Grafeo, all types except Null itself are nullable by default.

pub fn list_element_type(&self) -> Option<&LogicalType>

Returns the element type if this is a List, otherwise None.

pub fn can_coerce_from(&self, other: &LogicalType) -> bool

Checks if a value of other type can be implicitly coerced to this type.

pub fn common_type(&self, other: &LogicalType) -> Option<LogicalType>

Returns the common supertype of two types, if one exists.

Trait Implementations

impl Clone for LogicalType

fn clone(&self) -> LogicalType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalType

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

Formats the value using the given formatter.

impl Default for LogicalType

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LogicalType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LogicalType

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

Formats the value using the given formatter.

impl Hash for LogicalType

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 PartialEq for LogicalType

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for LogicalType

impl StructuralPartialEq for LogicalType