Enum Operation 

#[non_exhaustive]
pub enum Operation {
    Where(Condition),
    Select(Vec<SelectExpr>),
    Sort {
        field: String,
        descending: bool,
    },
    Limit(usize),
    Count {
        field: Option<String>,
    },
    Sum {
        field: String,
    },
    Avg {
        field: String,
    },
    Min {
        field: String,
    },
    Max {
        field: String,
    },
    Distinct {
        field: String,
    },
    Median {
        field: String,
    },
    Percentile {
        field: String,
        p: f64,
    },
    Stddev {
        field: String,
    },
    Variance {
        field: String,
    },
    Mode {
        field: String,
    },
    GroupConcat {
        field: String,
        separator: String,
    },
    GroupBy {
        fields: Vec<String>,
        having: Option<Condition>,
        aggregates: Vec<GroupAggregate>,
    },
    Unique,
    UniqueBy {
        field: String,
    },
    AddField {
        name: String,
        expr: Expr,
    },
    MapField {
        name: String,
        expr: Expr,
    },
    Explode {
        field: String,
    },
    Unpivot {
        value_columns: Vec<String>,
        key_name: String,
        value_name: String,
    },
    Pivot {
        index_fields: Vec<String>,
        columns_field: String,
        values_field: String,
    },
}

Pipeline operation applied after path navigation (e.g., | where ..., | sort ...).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Where(Condition)

where 필터링

Select(Vec<SelectExpr>)

select 컬럼 선택: select name, upper(name), round(price, 2)

Sort

sort 정렬: sort age (오름차순) / sort age desc (내림차순)

Fields

field: String

descending: bool

Limit(usize)

limit 결과 제한: limit 10

Count

count 전체 카운트 / count field 비null 카운트

Fields

field: Option<String>

Sum

sum field 숫자 필드 합계

Fields

field: String

Avg

avg field 숫자 필드 평균

Fields

field: String

Min

min field 최솟값

Fields

field: String

Max

max field 최댓값

Fields

field: String

Distinct

distinct field 고유값 목록

Fields

field: String

Median

median field 중앙값

Fields

field: String

Percentile

percentile field p p번째 백분위수 (p: 0.0~1.0)

Fields

field: String

p: f64

Stddev

stddev field 표준편차 (모집단)

Fields

field: String

Variance

variance field 분산

Fields

field: String

Mode

mode field 최빈값

Fields

field: String

GroupConcat

group_concat field separator 그룹 내 문자열 연결

Fields

field: String

separator: String

GroupBy

group_by field1, field2 그룹별 집계 집계 연산: group_by category | select category, count, sum_price

Fields

fields: Vec<String>

having: Option<Condition>

aggregates: Vec<GroupAggregate>

Unique

전체 레코드 동일성 기준 중복 제거

UniqueBy

특정 필드 기준 중복 제거 (첫 번째 등장 레코드 유지)

Fields

field: String

AddField

새 필드 추가 (computed column): --add-field 'total = amount * quantity'

Fields

name: String

expr: Expr

MapField

기존 필드 값 변환: --map 'name = upper(name)'

Fields

name: String

expr: Expr

Explode

배열 필드를 개별 행으로 펼침 (unnest/flatten): --explode tags

Fields

field: String

Unpivot

Unpivot (wide → long): 지정 컬럼들을 key-value 쌍으로 변환 예: [{name:“a”, jan:100, feb:200}] → [{name:“a”, variable:“jan”, value:100}, {name:“a”, variable:“feb”, value:200}]

Fields

value_columns: Vec<String>

피벗 해제할 컬럼명 목록

key_name: String

결과에서 컬럼명이 저장될 필드명 (기본: “variable”)

value_name: String

결과에서 값이 저장될 필드명 (기본: “value”)

Pivot

Pivot (long → wide): key-value 쌍을 컬럼으로 변환 예: [{name:“a”, month:“jan”, sales:100}, …] → [{name:“a”, jan:100, feb:200}]

Fields

index_fields: Vec<String>

유지할 인덱스 컬럼명 목록

columns_field: String

값이 새 컬럼명이 되는 필드

values_field: String

새 컬럼에 채울 값이 있는 필드

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 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 StructuralPartialEq for Operation