Struct InsertReplace

pub struct InsertReplace<'a> {
    pub type_: InsertReplaceType,
    pub flags: Vec<InsertReplaceFlag>,
    pub into_span: Option<Span>,
    pub table: QualifiedName<'a>,
    pub columns: Vec<Identifier<'a>>,
    pub values: Option<(Span, Vec<Vec<Expression<'a>>>)>,
    pub select: Option<Select<'a>>,
    pub set: Option<InsertReplaceSet<'a>>,
    pub on_duplicate_key_update: Option<InsertReplaceOnDuplicateKeyUpdate<'a>>,
    pub on_conflict: Option<OnConflict<'a>>,
    pub returning: Option<(Span, Vec<SelectExpr<'a>>)>,
}

Representation of Insert or Replace Statement

let sql1 = "INSERT INTO person (first_name, last_name) VALUES ('John', 'Doe')";
let stmt1 = parse_statement(sql1, &mut issues, &options);
let sql2 = "INSERT INTO contractor SELECT * FROM person WHERE status = 'c'";
let stmt2 = parse_statement(sql2, &mut issues, &options);
let sql3 = "INSERT INTO account (`key`, `value`) VALUES ('foo', 42)
            ON DUPLICATE KEY UPDATE `value`=`value`+42";
let stmt3 = parse_statement(sql3, &mut issues, &options);

let i: InsertReplace = match stmt1 {
    Some(Statement::InsertReplace(
        i @ InsertReplace{type_: InsertReplaceType::Insert(_), ..})) => i,
    _ => panic!("We should get an insert statement")
};

assert!(i.table.identifier.as_str() == "person");
println!("{:#?}", i.values.unwrap());


let sql = "REPLACE INTO t2 VALUES (1,'Leopard'),(2,'Dog')";
let stmt = parse_statement(sql, &mut issues, &options);
let r: InsertReplace = match stmt {
    Some(Statement::InsertReplace(
        r @ InsertReplace{type_: InsertReplaceType::Replace(_), ..})) => r,
    _ => panic!("We should get an replace statement")
};

assert!(r.table.identifier.as_str() == "t2");
println!("{:#?}", r.values.unwrap());

PostgreSQL

let sql4 = "INSERT INTO contractor SELECT * FROM person WHERE status = $1 ON CONFLICT (name) DO NOTHING";
let stmt4 = parse_statement(sql4, &mut issues, &options);

println!("{}", issues);

Fields

type_: InsertReplaceType

Span of “INSERT” or “REPLACE”

flags: Vec<InsertReplaceFlag>

Flags specified after “INSERT”

into_span: Option<Span>

Span of “INTO” if specified

table: QualifiedName<'a>

Table to insert into

columns: Vec<Identifier<'a>>

List of columns to set

values: Option<(Span, Vec<Vec<Expression<'a>>>)>

Span of values “VALUES” and list of tuples to insert if specified

select: Option<Select<'a>>

Select statement to insert if specified

set: Option<InsertReplaceSet<'a>>

Span of “SET” and list of key, value pairs to set if specified

on_duplicate_key_update: Option<InsertReplaceOnDuplicateKeyUpdate<'a>>

Updates to execute on duplicate key (mysql)

on_conflict: Option<OnConflict<'a>>

Action to take on duplicate keys (postgresql)

returning: Option<(Span, Vec<SelectExpr<'a>>)>

Span of “RETURNING” and select expressions after “RETURNING”, if “RETURNING” is present

Trait Implementations

impl<'a> Clone for InsertReplace<'a>

fn clone(&self) -> InsertReplace<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for InsertReplace<'a>

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

Formats the value using the given formatter.

impl<'a> Spanned for InsertReplace<'a>

fn span(&self) -> Span

Compute byte span of an ast fragment

fn join_span(&self, other: &impl OptSpanned) -> Span

Compute the minimal span containing both self and other