Enum Operation 

pub enum Operation {
    Select(ParsedParams, Option<PreferOptions>),
    Insert(InsertParams, Option<PreferOptions>),
    Update(UpdateParams, Option<PreferOptions>),
    Delete(DeleteParams, Option<PreferOptions>),
    Rpc(RpcParams, Option<PreferOptions>),
}

Represents all supported PostgREST operations (GET, POST, PATCH, DELETE, PUT, RPC).

Each variant contains operation-specific parameters and optional Prefer header preferences.

Examples

use postgrest_parser::{parse, Operation};

// Parse a SELECT operation
let op = parse("GET", "users", "id=eq.123", None, None).unwrap();
match op {
    Operation::Select(params, prefer) => {
        assert!(params.has_filters());
        assert!(prefer.is_none());
    }
    _ => panic!("Expected Select"),
}

// Parse an INSERT operation
let body = r#"{"name": "Alice", "email": "alice@example.com"}"#;
let op = parse("POST", "users", "", Some(body), None).unwrap();
match op {
    Operation::Insert(params, _) => {
        assert!(!params.values.is_empty());
    }
    _ => panic!("Expected Insert"),
}

Variants

Select(ParsedParams, Option<PreferOptions>)

SELECT query with parsed parameters and optional Prefer header

Insert(InsertParams, Option<PreferOptions>)

INSERT query with values, conflict resolution, and optional Prefer header

Update(UpdateParams, Option<PreferOptions>)

UPDATE query with SET values, filters, and optional Prefer header

Delete(DeleteParams, Option<PreferOptions>)

DELETE query with filters and optional Prefer header

Rpc(RpcParams, Option<PreferOptions>)

RPC function call with arguments, filters, and optional Prefer header

Trait Implementations

impl Clone for Operation

fn clone(&self) -> Operation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Operation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Operation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Operation

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

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 Operation