Enum CreateTableBody 

pub enum CreateTableBody<X: Extension = NoExt> {
    Definition {
        elements: ThinVec<TableElement<X>>,
        meta: Meta,
    },
    AsQuery {
        columns: ThinVec<Ident>,
        query: Box<Query<X>>,
        with_data: Option<bool>,
        meta: Meta,
    },
    AsExecute {
        columns: ThinVec<Ident>,
        execute: Box<ExecuteStatement<X>>,
        with_data: Option<bool>,
        meta: Meta,
    },
    PartitionOf {
        parent: ObjectName,
        elements: ThinVec<TableElement<X>>,
        bound: Box<PartitionBound<X>>,
        meta: Meta,
    },
    OfType {
        type_name: ObjectName,
        elements: ThinVec<TableElement<X>>,
        meta: Meta,
    },
    LikeSource {
        source: ObjectName,
        parenthesized: bool,
        meta: Meta,
    },
}

The CREATE TABLE body: a (elements) definition, an AS <query>, a PARTITION OF declarative-partitioning child, or an OF <type> typed table.

Variants

Definition

A parenthesized (col …, constraint …) column/constraint definition list.

Fields

elements: ThinVec<TableElement<X>>

elements in source order.

meta: Meta

Source location and node identity.

AsQuery

A CREATE TABLE … AS <query> — populate the table from a query.

Fields

columns: ThinVec<Ident>

Columns in source order.

query: Box<Query<X>>

Query governed by this node.

with_data: Option<bool>

Whether the with data form was present in the source.

meta: Meta

Source location and node identity.

AsExecute

AS EXECUTE <prepared> [(<arg>, ...)] [WITH [NO] DATA] — a CTAS whose source rows come from running a prepared statement rather than an inline query (PostgreSQL’s CreateTableAsStmt over an ExecuteStmt, CREATE TABLE t AS EXECUTE plan(1, 2)). The optional columns rename the result columns (empty when the (...) list is absent) exactly as on AsQuery, and the same trailing WITH [NO] DATA populate flag rides here. The prepared-statement source is a reused ExecuteStatement (name + positional args), boxed to keep this variant within the enum’s size budget. Gated for acceptance by CreateTableClauseSyntax::create_table_as_execute; off elsewhere, where EXECUTE after AS is left unconsumed and surfaces as a clean parse error (the inline-query CTAS path takes over and rejects the EXECUTE keyword).

Fields

columns: ThinVec<Ident>

Columns in source order.

execute: Box<ExecuteStatement<X>>

The prepared statement executed to populate the table; see ExecuteStatement.

with_data: Option<bool>

Whether the with data form was present in the source.

meta: Meta

Source location and node identity.

PartitionOf

PARTITION OF <parent> [(<augmentation>, ...)] <bound> — a declarative-partitioning child, whose column shape is inherited from parent (PostgreSQL). The optional parenthesized augmentation list carries per-column overrides (a bare ColId with a [WITH OPTIONS] constraint list — no type, so each ColumnDef leaves data_type None) and table constraints; it reuses TableElement and stays empty when the (...) is absent (PostgreSQL rejects an empty ()). The bound is the mandatory FOR VALUES … / DEFAULT partition-bound spec. Gated for acceptance by CreateTableClauseSyntax::declarative_partitioning; off elsewhere, PARTITION after the table name surfaces as a clean parse error.

Fields

parent: ObjectName

The parent partitioned table (PARTITION OF <parent>).

elements: ThinVec<TableElement<X>>

elements in source order.

bound: Box<PartitionBound<X>>

The partition bound (FOR VALUES … / DEFAULT); see PartitionBound.

meta: Meta

Source location and node identity.

OfType

OF <type_name> [(<augmentation>, ...)] — a typed table whose column shape is drawn from a composite type (PostgreSQL). Like PartitionOf the optional parenthesized list augments rather than declares: each element is a bare ColId with an optional WITH OPTIONS noise phrase and a constraint list (no type — the column’s type comes from type_name, so each ColumnDef leaves data_type None) or a table constraint. It reuses TableElement and stays empty when the (...) is absent (PostgreSQL rejects an empty ()). Unlike the (elements) Definition body, the OF form takes no INHERITS clause (CREATE TABLE t OF ty INHERITS (p) is a raw-parse error), so CreateTable::inherits is always empty for it. Gated for acceptance by CreateTableClauseSyntax::typed_tables; off elsewhere, OF after the table name surfaces as a clean parse error.

Fields

type_name: ObjectName

The composite type the table is defined OF (CREATE TABLE t OF <type>).

elements: ThinVec<TableElement<X>>

elements in source order.

meta: Meta

Source location and node identity.

LikeSource

LIKE <source> / (LIKE <source>) — MySQL’s statement-level table-clone body, which copies the whole definition of an existing table (CREATE TABLE t LIKE src). Unlike PostgreSQL’s TableElement::Like copy element (which sits inside a (elements) Definition list, carries {INCLUDING | EXCLUDING} <feature> options, and can co-occur with other elements — gated by CreateTableClauseSyntax::like_source_table), this is a whole-statement production that replaces the entire body: exactly one bare source name, no feature-copy options, no co-element, no trailing table options — MySQL rejects LIKE src ENGINE=…, (LIKE src, x INT), and (LIKE src INCLUDING ALL) all as ER_PARSE_ERROR. MySQL spells it two ways, differing only by optional parentheses (parenthesized records which so the source form round-trips); both admit a qualified source name and compose freely with IF NOT EXISTS and TEMPORARY. Gated for acceptance by CreateTableClauseSyntax::statement_level_table_like; off elsewhere, LIKE after the table name (or as the first token inside () is left unconsumed and surfaces as a clean parse error.

Fields

source: ObjectName

Input source for this syntax.

parenthesized: bool

Whether the source was written parenthesized ((LIKE src)) rather than bare (LIKE src). Both are the same MySQL production; this preserves the spelling.

meta: Meta

Source location and node identity.

Trait Implementations

impl<X: Clone + Extension> Clone for CreateTableBody<X>

fn clone(&self) -> CreateTableBody<X>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X: Debug + Extension> Debug for CreateTableBody<X>

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for CreateTableBody<X>

where X: Deserialize<'de> + Extension,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X: Eq + Extension> Eq for CreateTableBody<X>

impl<X: Hash + Extension> Hash for CreateTableBody<X>

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<X: PartialEq + Extension> PartialEq for CreateTableBody<X>

fn eq(&self, other: &CreateTableBody<X>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<X: Extension + Render> Render for CreateTableBody<X>

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

Return the render for this value.

fn operand_binding_power(&self) -> Option<BindingPower>

The binding power this node contributes when it appears as an operand, or None (the default) for a self-delimiting node — an atom, call, or constructor — that never needs parentheses.

impl<X> Serialize for CreateTableBody<X>

where X: Serialize + Extension,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<X: Extension> Spanned for CreateTableBody<X>

fn span(&self) -> Span

Return the span for this value.

impl<X: PartialEq + Extension> StructuralPartialEq for CreateTableBody<X>