Struct LoadDataStatement 

pub struct LoadDataStatement<X: Extension = NoExt> {

    pub format: LoadDataFormat,
    pub concurrency: Option<LoadDataConcurrency>,
    pub local: bool,
    pub file: Literal,
    pub on_duplicate: Option<LoadDataDuplicate>,
    pub table: ObjectName,
    pub partitions: ThinVec<Ident>,
    pub charset: Option<Ident>,
    pub rows_identified_by: Option<Literal>,
    pub fields: Option<LoadDataFields>,
    pub lines: Option<LoadDataLines>,
    pub ignore_rows: Option<LoadDataIgnoreRows>,
    pub columns: ThinVec<LoadDataFieldOrVar>,
    pub set: ThinVec<UpdateAssignment<X>>,
    pub meta: Meta,
}

A MySQL LOAD {DATA | XML} … INFILE … INTO TABLE … bulk-import statement (gated by UtilitySyntax::load_data).

One node covers both the DATA (delimited text) and XML readings, distinguished by format: the mysql sql_yacc.yy load_stmt rule is a single data_or_xml production whose whole clause train is grammatically shared, so at the parse layer the two forms differ only in the DATA/XML keyword. The clauses MySQL restricts to one reading (FIELDS/LINES are meaningless under XML, ROWS IDENTIFIED BY under DATA) are semantic restrictions the server enforces only after it has parsed the whole statement and resolved the table — every clause parses under either format (engine-measured on mysql:8.4.10: a LOAD XML … FIELDS TERMINATED BY ',' reaches ER_NO_SUCH_TABLE 1146, not ER_PARSE_ERROR 1064), so this node does not gate them by format and the parse layer leaves that binding verdict untouched (the PrepareStatement “grammar accepts, bind restricts” contract).

The clause train is strictly order-sensitive (engine-measured: any out-of-order clause is ER_PARSE_ERROR 1064), so the node’s field order is the grammar’s canonical order and the renderer emits that order. The optional clauses are None/empty when absent. Generic over the extension X because the set assignments carry full expressions.

Scope boundary: the MySQL 8.4 secondary-engine bulk-load extension clauses on the same load_stmt rule — the FROM keyword, URL/S3 source types, COUNT n, IN PRIMARY KEY ORDER, COMPRESSION, PARALLEL, MEMORY, and ALGORITHM = BULK — are a distinct cloud-bulk-load feature family and are intentionally not modelled here (they take their own follow-up; see the ticket close note). This node is the classic documented LOAD DATA / LOAD XML surface.

Fields

format: LoadDataFormat

Whether the source is delimited text (LOAD DATA) or XML (LOAD XML); see LoadDataFormat.

concurrency: Option<LoadDataConcurrency>

The optional table-lock concurrency modifier (LOW_PRIORITY / CONCURRENT); see LoadDataConcurrency. None for the default lock (load_data_lock %empty).

local: bool

true when the LOCAL keyword was written (the file is read from the client rather than the server host).

file: Literal

The INFILE '<path>' source-file string literal (TEXT_STRING_filesystem); only the INFILE source type is modelled (see the type-level scope note).

on_duplicate: Option<LoadDataDuplicate>

The optional duplicate-key handling (REPLACE / IGNORE); see LoadDataDuplicate. None for the default (error on duplicate).

table: ObjectName

The INTO TABLE <name> destination table.

partitions: ThinVec<Ident>

The PARTITION (<name> [, ...]) partition list; empty when the clause is absent. The list is never a written empty () — MySQL requires at least one partition name.

charset: Option<Ident>

The CHARACTER SET <name> charset override (opt_load_data_charset); None when absent. Held as a single Ident (a charset name, not a dotted ObjectName).

rows_identified_by: Option<Literal>

The ROWS IDENTIFIED BY '<tag>' row element tag (opt_xml_rows_identified_by); None when absent. Grammar-shared by both formats (see the type-level note) though only meaningful under XML.

fields: Option<LoadDataFields>

The {FIELDS | COLUMNS} … field-format clause; None when absent. See LoadDataFields.

lines: Option<LoadDataLines>

The LINES … line-format clause; None when absent. See LoadDataLines.

ignore_rows: Option<LoadDataIgnoreRows>

The IGNORE <n> {LINES | ROWS} header-skip clause; None when absent. See LoadDataIgnoreRows.

columns: ThinVec<LoadDataFieldOrVar>

The parenthesized (col_or_var [, ...]) target list; empty when absent (or a written empty (), which MySQL folds to absent — '(' ')' yields the same nullptr as an omitted list). See LoadDataFieldOrVar.

set: ThinVec<UpdateAssignment<X>>

The SET col = {expr | DEFAULT} [, ...] post-load assignments; empty when absent. Reuses UpdateAssignment exactly as INSERT … SET does (mysql load_data_set_elem is simple_ident_nospvar equal expr_or_default, the single-column-assignment shape); a tuple assignment is not grammar-valid here, and the fitted MySql preset never emits one (its multi_column_assignment gate is off).

meta: Meta

Source location and node identity.

Trait Implementations

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

fn clone(&self) -> LoadDataStatement<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 LoadDataStatement<X>

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for LoadDataStatement<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 LoadDataStatement<X>

impl<X: Hash + Extension> Hash for LoadDataStatement<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 LoadDataStatement<X>

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

Equality operator ==.

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

Inequality operator !=.

impl<X: Extension + Render> Render for LoadDataStatement<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 LoadDataStatement<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 LoadDataStatement<X>

fn span(&self) -> Span

Return the span for this value.

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