Enum Expr 

pub enum Expr {
    Column(String),
    Literal(ScalarValue),
    Eq(Box<Expr>, Box<Expr>),
    Neq(Box<Expr>, Box<Expr>),
    Gt(Box<Expr>, Box<Expr>),
    Gte(Box<Expr>, Box<Expr>),
    Lt(Box<Expr>, Box<Expr>),
    Lte(Box<Expr>, Box<Expr>),
    And(Vec<Expr>),
    Or(Vec<Expr>),
    Not(Box<Expr>),
    IsTransition,
    IsTransversion,
    IsSnp,
    IsIndel,
    IsPass,
    InRegion(GenomicInterval),
    InRegions(Vec<GenomicInterval>),
    OnChromosome(String),
    Contains(Box<Expr>, Box<Expr>),
    StartsWith(Box<Expr>, Box<Expr>),
    Matches(Box<Expr>, String),
    Count,
    Mean(Box<Expr>),
    Sum(Box<Expr>),
    Min(Box<Expr>),
    Max(Box<Expr>),
    TsTvRatio,
    AlleleFrequency,
}

Expression in the GenomicFrame query language

Expressions form an abstract syntax tree (AST) that represents operations on genomic data. They are lazy - constructing an expression doesn’t execute anything, it just builds a plan that can later be optimized and executed.

Variants

Column(String)

Reference to a column by name (e.g., “qual”, “chrom”, “pos”)

Literal(ScalarValue)

Literal scalar value

Eq(Box<Expr>, Box<Expr>)

Equal: column == value

Neq(Box<Expr>, Box<Expr>)

Not equal: column != value

Gt(Box<Expr>, Box<Expr>)

Greater than: column > value

Gte(Box<Expr>, Box<Expr>)

Greater than or equal: column >= value

Lt(Box<Expr>, Box<Expr>)

Less than: column < value

Lte(Box<Expr>, Box<Expr>)

Less than or equal: column <= value

And(Vec<Expr>)

Logical AND of multiple expressions

Or(Vec<Expr>)

Logical OR of multiple expressions

Not(Box<Expr>)

Logical NOT

IsTransition

Test if variant is a transition (A<->G or C<->T)

IsTransversion

Test if variant is a transversion

IsSnp

Test if variant is a SNP (single nucleotide polymorphism)

IsIndel

Test if variant is an indel (insertion/deletion)

IsPass

Test if variant passed all filters (FILTER == “PASS”)

InRegion(GenomicInterval)

Test if record overlaps a genomic region

InRegions(Vec<GenomicInterval>)

Test if record overlaps any of multiple regions

OnChromosome(String)

Test if chromosome matches

Contains(Box<Expr>, Box<Expr>)

String contains substring

StartsWith(Box<Expr>, Box<Expr>)

String starts with prefix

Matches(Box<Expr>, String)

String matches regex pattern

Count

Count records

Mean(Box<Expr>)

Mean of expression values

Sum(Box<Expr>)

Sum of expression values

Min(Box<Expr>)

Minimum value

Max(Box<Expr>)

Maximum value

TsTvRatio

Transition/transversion ratio (genomic-specific)

AlleleFrequency

Allele frequency calculation

Implementations

impl Expr

pub fn eq(self, other: Expr) -> Expr

Create an equality comparison

pub fn neq(self, other: Expr) -> Expr

Create a not-equal comparison

pub fn gt(self, other: Expr) -> Expr

Create a greater-than comparison

pub fn gte(self, other: Expr) -> Expr

Create a greater-than-or-equal comparison

pub fn lt(self, other: Expr) -> Expr

Create a less-than comparison

pub fn lte(self, other: Expr) -> Expr

Create a less-than-or-equal comparison

pub fn and(self, other: Expr) -> Expr

Combine with AND

pub fn or(self, other: Expr) -> Expr

Combine with OR

pub fn not(self) -> Expr

Negate this expression

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl ExprToFilter<BamRecord> for Expr

fn compile(&self) -> Result<Box<dyn RecordFilter<BamRecord>>>

Compile this expression into a filter for record type R

impl ExprToFilter<BedRecord> for Expr

fn compile(&self) -> Result<Box<dyn RecordFilter<BedRecord>>>

Compile this expression into a filter for record type R

impl ExprToFilter<FastqRecord> for Expr

fn compile(&self) -> Result<Box<dyn RecordFilter<FastqRecord>>>

Compile this expression into a filter for record type R

impl ExprToFilter<VcfRecord> for Expr

fn compile(&self) -> Result<Box<dyn RecordFilter<VcfRecord>>>

Compile this expression into a filter for record type R

impl PartialEq for Expr

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