Struct OnConflict 

pub struct OnConflict {
    pub columns: Vec<String>,
    pub action: ConflictAction,
    pub where_clause: Option<Vec<LogicCondition>>,
    pub update_columns: Option<Vec<String>>,
}

ON CONFLICT clause for upsert operations.

Supports both basic conflict resolution and advanced features like partial unique indexes and selective column updates.

Examples

use postgrest_parser::{OnConflict, ConflictAction};

// Basic upsert: ON CONFLICT (email) DO UPDATE SET ...
let conflict = OnConflict::do_update(vec!["email".to_string()]);
assert_eq!(conflict.action, ConflictAction::DoUpdate);

// Ignore conflicts: ON CONFLICT (id) DO NOTHING
let conflict = OnConflict::do_nothing(vec!["id".to_string()]);
assert_eq!(conflict.action, ConflictAction::DoNothing);

// Partial unique index: ON CONFLICT (email) WHERE deleted_at IS NULL
use postgrest_parser::{parse_filter, LogicCondition};
let filter = parse_filter("deleted_at", "is.null").unwrap();
let conflict = OnConflict::do_update(vec!["email".to_string()])
    .with_where_clause(vec![LogicCondition::Filter(filter)]);
assert!(conflict.where_clause.is_some());

// Selective update: ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name
let conflict = OnConflict::do_update(vec!["id".to_string()])
    .with_update_columns(vec!["name".to_string()]);
assert_eq!(conflict.update_columns.unwrap().len(), 1);

Fields

columns: Vec<String>

Columns that define the conflict target (unique constraint or index)

action: ConflictAction

Action to take on conflict: DO NOTHING or DO UPDATE

where_clause: Option<Vec<LogicCondition>>

Optional WHERE clause for partial unique index

Example: ON CONFLICT (email) WHERE deleted_at IS NULL

update_columns: Option<Vec<String>>

Specific columns to update on conflict (if None, all columns are updated)

Example: ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name

Implementations

impl OnConflict

pub fn do_nothing(columns: Vec<String>) -> Self

Creates an ON CONFLICT … DO NOTHING clause.

pub fn do_update(columns: Vec<String>) -> Self

Creates an ON CONFLICT … DO UPDATE clause.

pub fn with_where_clause(self, where_clause: Vec<LogicCondition>) -> Self

Adds a WHERE clause for partial unique index support.

pub fn with_update_columns(self, update_columns: Vec<String>) -> Self

Specifies which columns to update (instead of all columns).

Trait Implementations

impl Clone for OnConflict

fn clone(&self) -> OnConflict

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OnConflict

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OnConflict

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OnConflict

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OnConflict