Struct UpsertStatement 

pub struct UpsertStatement<'a> {
    pub table_name: &'a str,
    pub values: Vec<(&'a str, Box<dyn Expression>)>,
    pub filters: Option<Vec<Box<dyn BooleanExpression>>>,
    pub unique: Option<&'a [&'a str]>,
    pub limit: Option<usize>,
}

UPSERT statement for inserting or updating a row on conflict

Fields

table_name: &'a str

Table to upsert into

values: Vec<(&'a str, Box<dyn Expression>)>

Column-value pairs to insert/update

filters: Option<Vec<Box<dyn BooleanExpression>>>

WHERE clause filters for conditional upsert

unique: Option<&'a [&'a str]>

Columns that form the unique constraint to detect conflicts

limit: Option<usize>

Maximum number of rows to upsert

Implementations

impl<'a> UpsertStatement<'a>

pub fn values<T>(self, values: Vec<(&'a str, T)>) -> UpsertStatement<'a>

where T: Into<Box<dyn Expression>>,

Sets multiple column-value pairs to upsert

pub fn value<T>(self, name: &'a str, value: T) -> UpsertStatement<'a>

where T: Into<Box<dyn Expression>>,

Sets a single column-value pair to upsert

pub fn value_opt<T>( self, name: &'a str, value: Option<T>, ) -> UpsertStatement<'a>

where T: Into<Box<dyn Expression>>,

Sets a column-value pair only if the value is Some

This is useful for conditional updates where a value should only be set if present.

pub const fn unique(self, unique: &'a [&'a str]) -> UpsertStatement<'a>

Specifies unique columns that identify conflicts

These columns determine when to update instead of insert.

pub const fn limit(self, limit: usize) -> UpsertStatement<'a>

Limits the number of rows affected by the upsert

pub async fn execute(self, db: &dyn Database) -> Result<Vec<Row>, DatabaseError>

Errors

Will return Err if the upsert execution failed.

pub async fn execute_first( self, db: &dyn Database, ) -> Result<Row, DatabaseError>

Errors

Will return Err if the upsert execution failed.

Trait Implementations

impl Executable for UpsertStatement<'_>

Implement Executable for UpsertStatement

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, db: &'life1 dyn Database, ) -> Pin<Box<dyn Future<Output = Result<(), DatabaseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, UpsertStatement<'_>: 'async_trait,

Execute this operation against the database

impl FilterableQuery for UpsertStatement<'_>

fn filter(self, filter: Box<dyn BooleanExpression>) -> UpsertStatement<'_>

Adds a single filter condition to the WHERE clause

fn filters(self, filters: Vec<Box<dyn BooleanExpression>>) -> Self

Adds multiple filter conditions to the query

fn filter_if_some<T>(self, filter: Option<T>) -> Self

where T: BooleanExpression + 'static,

Conditionally adds a filter if the option contains a value

fn where_in<L, V>(self, left: L, values: V) -> Self

where L: Into<Identifier>, V: Into<Box<dyn List>>,

Adds an IN clause filter (column IN (values…))

fn where_not_in<L, V>(self, left: L, values: V) -> Self

where L: Into<Identifier>, V: Into<Box<dyn List>>,

Adds a NOT IN clause filter (column NOT IN (values…))

fn where_and(self, conditions: Vec<Box<dyn BooleanExpression>>) -> Self

Adds a logical AND filter combining multiple conditions

fn where_or(self, conditions: Vec<Box<dyn BooleanExpression>>) -> Self

Adds a logical OR filter combining multiple conditions

fn where_eq<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

Adds an equality comparison filter (column = value)

fn where_not_eq<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

Adds a not-equal comparison filter (column != value)

fn where_gt<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

Adds a greater-than comparison filter (column > value)

fn where_gte<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

Adds a greater-than-or-equal comparison filter (column >= value)

fn where_lt<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

Adds a less-than comparison filter (column < value)

fn where_lte<L, R>(self, left: L, right: R) -> Self

where L: Into<Identifier>, R: Into<Box<dyn Expression>>,

Adds a less-than-or-equal comparison filter (column <= value)

impl<'a> From<UpsertStatement<'a>> for SelectQuery<'a>

fn from(value: UpsertStatement<'a>) -> SelectQuery<'a>

Converts to this type from the input type.