rxgraph 0.2.0__tar.gz → 0.3.1__tar.gz

{rxgraph-0.2.0 → rxgraph-0.3.1}/Cargo.lock

@@ -1293,7 +1293,7 @@ checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "rxgraph"
-version = "0.2.0"
+version = "0.3.1"
 dependencies = [
  "anyhow",
  "arrow",
@@ -1311,7 +1311,7 @@ dependencies = [
 
 [[package]]
 name = "rxgraph-python"
-version = "0.2.0"
+version = "0.3.1"
 dependencies = [
  "anyhow",
  "arrow",

{rxgraph-0.2.0 → rxgraph-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rxgraph
-Version: 0.2.0
+Version: 0.3.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{rxgraph-0.2.0 → rxgraph-0.3.1}/crates/rxgraph/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rxgraph"
-version = "0.2.0"
+version = "0.3.1"
 edition.workspace = true
 rust-version.workspace = true
 description = "High-performance graph traversal engine"
@@ -40,3 +40,7 @@ harness = false
 [[bench]]
 name = "flight_routes"
 harness = false
+
+[[bench]]
+name = "memory"
+harness = false

rxgraph-0.3.1/crates/rxgraph/benches/memory.rs

@@ -0,0 +1,121 @@
+//! Memory benchmarking for graph construction, holding, and from-source search.
+//!
+//! Unlike the criterion benches (which measure time), this binary uses `stats_alloc` to
+//! report allocation deltas at each stage. Run with:
+//!
+//! ```sh
+//! cargo bench -p rxgraph --bench memory
+//! ```
+//!
+//! It builds a large, sparse graph where only a small subset is reachable from the source,
+//! and reports bytes allocated/RSS.
+
+use std::{alloc::System, hint::black_box, sync::Arc, time::Instant};
+
+use arrow::{
+    array::{ArrayRef, UInt64Array},
+    datatypes::{DataType, Field, Schema},
+    record_batch::RecordBatch,
+};
+use rxgraph::Graph;
+use stats_alloc::{INSTRUMENTED_SYSTEM, Region, StatsAlloc};
+
+#[global_allocator]
+static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;
+
+/// Number of nodes in the synthetic graph.
+const NODES: u64 = 5_000_000;
+/// Length of the single reachable chain from node 0 (the "working set").
+const REACHABLE_CHAIN: u64 = 5_000;
+
+fn batch(fields: Vec<Field>, columns: Vec<ArrayRef>) -> RecordBatch {
+    RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap()
+}
+
+/// Builds a graph with `NODES` contiguous u64 node ids and a single linear chain of
+/// `REACHABLE_CHAIN` edges from node 0. Everything past the chain is unreachable, so a
+/// search from node 0 only ever needs a tiny working set.
+fn tables() -> (RecordBatch, RecordBatch) {
+    let node_ids: Vec<u64> = (0..NODES).collect();
+    let nodes = batch(
+        vec![Field::new("id", DataType::UInt64, false)],
+        vec![Arc::new(UInt64Array::from(node_ids)) as ArrayRef],
+    );
+
+    let edge_count = REACHABLE_CHAIN;
+    let edge_ids: Vec<u64> = (0..edge_count).collect();
+    let srcs: Vec<u64> = (0..edge_count).collect();
+    let dests: Vec<u64> = (1..=edge_count).collect();
+    let edges = batch(
+        vec![
+            Field::new("id", DataType::UInt64, false),
+            Field::new("src", DataType::UInt64, false),
+            Field::new("dest", DataType::UInt64, false),
+        ],
+        vec![
+            Arc::new(UInt64Array::from(edge_ids)) as ArrayRef,
+            Arc::new(UInt64Array::from(srcs)),
+            Arc::new(UInt64Array::from(dests)),
+        ],
+    );
+
+    (nodes, edges)
+}
+
+fn mib(bytes: isize) -> f64 {
+    bytes as f64 / (1024.0 * 1024.0)
+}
+
+/// Runs the received callback inside an allocation-tracking region and reports memory use.
+///
+/// Two distinct numbers are reported:
+/// - `retained`: net bytes still held after the call returns (allocated minus freed). This
+///   is what grows the resident set. A value that escapes the closure (e.g. the graph)
+///   counts here; a result that is dropped inside the closure does not.
+/// - `churn`: total bytes allocated during the call, regardless of whether they were freed
+///   again before returning. High churn with ~zero retained means lots of short-lived
+///   allocations (e.g. WCC building one Vec per component, then handing it back and dropping
+///   it), not a memory leak.
+fn measure<T>(label: &str, f: impl FnOnce() -> T) -> T {
+    let region = Region::new(GLOBAL);
+    let started = Instant::now();
+    let value = f();
+    let stats = region.change();
+    let elapsed = started.elapsed();
+    let retained = stats.bytes_allocated as isize - stats.bytes_deallocated as isize;
+    eprintln!(
+        "{label:<28} retained={:>9.2} MiB  churn={:>8.2} MiB in {:<8} allocs (freed={:.2} MiB)  {elapsed:?}",
+        mib(retained),
+        mib(stats.bytes_allocated as isize),
+        stats.allocations,
+        mib(stats.bytes_deallocated as isize),
+    );
+    value
+}
+
+fn main() {
+    eprintln!("memory profile: nodes={NODES} reachable_chain={REACHABLE_CHAIN}\n");
+
+    let (nodes, edges) = tables();
+
+    // Construction: forward CSR + identity only. Reverse CSR is NOT built here (lazy).
+    let graph = measure("construct", || Graph::new(nodes, edges).unwrap());
+
+    // Forward-only BFS from node 0: touches only the reachable chain.
+    measure("bfs_from_source", || {
+        black_box(graph.bfs_u64(0, None).unwrap());
+    });
+
+    // First degree query forces the lazy reverse CSR to materialize.
+    measure("in_degrees (builds rev CSR)", || {
+        black_box(graph.in_degrees());
+    });
+
+    // Subsequent reverse-adjacency use is free (cached).
+    measure("weakly_connected (rev cached)", || {
+        black_box(graph.weakly_connected_components_u64());
+    });
+
+    // Keep the graph alive so its footprint is attributed to the stages above.
+    black_box(&graph);
+}

{rxgraph-0.2.0 → rxgraph-0.3.1}/crates/rxgraph/src/dsl/arrow_value.rs

@@ -1,4 +1,4 @@
-use std::{io::Cursor, sync::Arc};
+use std::{cmp::Ordering, io::Cursor, sync::Arc};
 
 use anyhow::{Context, Result, bail};
 use arrow::{
@@ -12,7 +12,7 @@ use arrow::{
     record_batch::RecordBatch,
 };
 
-use crate::dsl::Value;
+use crate::dsl::{Value, ops::scalar::ScalarOp};
 
 #[derive(Debug, Clone)]
 pub(crate) enum ColumnReader {
@@ -35,6 +35,13 @@ pub(crate) enum ColumnReader {
     Struct(StructArray),
 }
 
+enum ScalarValueRef<'a> {
+    Null,
+    Bool(bool),
+    Number(f64),
+    Str(&'a str),
+}
+
 impl ColumnReader {
     pub(crate) fn bind(batch: &RecordBatch, name: &str) -> Result<Self> {
         let column = batch
@@ -106,6 +113,164 @@ impl ColumnReader {
             Self::Struct(array) => nullable!(array, struct_row_to_value(array, row)?),
         })
     }
+
+    pub(crate) fn eval_scalar_literal(
+        &self,
+        row: usize,
+        op: ScalarOp,
+        literal: &Value,
+        reverse: bool,
+    ) -> Result<Option<Value>> {
+        let Some(value) = self.scalar_value(row) else {
+            return Ok(None);
+        };
+        Ok(Some(match value {
+            ScalarValueRef::Null => eval_null_literal(op, literal),
+            ScalarValueRef::Bool(value) => eval_bool_literal(value, op, literal, reverse)?,
+            ScalarValueRef::Number(value) => eval_number_literal(value, op, literal, reverse)?,
+            ScalarValueRef::Str(value) => eval_str_literal(value, op, literal, reverse)?,
+        }))
+    }
+
+    fn scalar_value(&self, row: usize) -> Option<ScalarValueRef<'_>> {
+        macro_rules! nullable {
+            ($array:expr, $value:expr) => {
+                if $array.is_null(row) {
+                    ScalarValueRef::Null
+                } else {
+                    $value
+                }
+            };
+        }
+
+        Some(match self {
+            Self::Bool(array) => nullable!(array, ScalarValueRef::Bool(array.value(row))),
+            Self::I8(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::I16(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::I32(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::I64(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::U8(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::U16(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::U32(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::U64(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::F32(array) => nullable!(array, ScalarValueRef::Number(array.value(row) as f64)),
+            Self::F64(array) => nullable!(array, ScalarValueRef::Number(array.value(row))),
+            Self::Utf8(array) => nullable!(array, ScalarValueRef::Str(array.value(row))),
+            Self::LargeUtf8(array) => nullable!(array, ScalarValueRef::Str(array.value(row))),
+            Self::Utf8View(array) => nullable!(array, ScalarValueRef::Str(array.value(row))),
+            Self::List(_) | Self::LargeList(_) | Self::Struct(_) => return None,
+        })
+    }
+}
+
+fn eval_null_literal(op: ScalarOp, literal: &Value) -> Value {
+    match op {
+        ScalarOp::Eq => Value::Bool(literal.is_null()),
+        ScalarOp::NotEq => Value::Bool(!literal.is_null()),
+        ScalarOp::Lt | ScalarOp::LtEq | ScalarOp::Gt | ScalarOp::GtEq => Value::Null,
+        _ => unreachable!("fast scalar literal only handles comparison ops"),
+    }
+}
+
+fn eval_non_null_null_literal(op: ScalarOp) -> Value {
+    match op {
+        ScalarOp::Eq => Value::Bool(false),
+        ScalarOp::NotEq => Value::Bool(true),
+        ScalarOp::Lt | ScalarOp::LtEq | ScalarOp::Gt | ScalarOp::GtEq => Value::Null,
+        _ => unreachable!("fast scalar literal only handles comparison ops"),
+    }
+}
+
+fn eval_bool_literal(value: bool, op: ScalarOp, literal: &Value, reverse: bool) -> Result<Value> {
+    if literal.is_null() {
+        return Ok(eval_non_null_null_literal(op));
+    }
+    let Some(rhs) = literal_bool(literal) else {
+        return eval_incomparable_literal(op);
+    };
+    Ok(eval_ordering_or_eq(
+        op,
+        value == rhs,
+        value.cmp(&rhs),
+        reverse,
+    ))
+}
+
+fn eval_number_literal(value: f64, op: ScalarOp, literal: &Value, reverse: bool) -> Result<Value> {
+    if literal.is_null() {
+        return Ok(eval_non_null_null_literal(op));
+    }
+    let Some(rhs) = literal.as_f64() else {
+        return eval_incomparable_literal(op);
+    };
+    match op {
+        ScalarOp::Eq => Ok(Value::Bool(value == rhs)),
+        ScalarOp::NotEq => Ok(Value::Bool(value != rhs)),
+        ScalarOp::Lt | ScalarOp::LtEq | ScalarOp::Gt | ScalarOp::GtEq => {
+            let ordering = value.partial_cmp(&rhs).context("cannot compare values")?;
+            Ok(Value::Bool(apply_ordering(op, ordering, reverse)))
+        }
+        _ => unreachable!("fast scalar literal only handles comparison ops"),
+    }
+}
+
+fn eval_str_literal(value: &str, op: ScalarOp, literal: &Value, reverse: bool) -> Result<Value> {
+    if literal.is_null() {
+        return Ok(eval_non_null_null_literal(op));
+    }
+    let Value::Str(rhs) = literal else {
+        return eval_incomparable_literal(op);
+    };
+    Ok(eval_ordering_or_eq(
+        op,
+        value == rhs.as_ref(),
+        value.cmp(rhs.as_ref()),
+        reverse,
+    ))
+}
+
+fn literal_bool(literal: &Value) -> Option<bool> {
+    match literal {
+        Value::Bool(value) => Some(*value),
+        _ => None,
+    }
+}
+
+fn eval_incomparable_literal(op: ScalarOp) -> Result<Value> {
+    match op {
+        ScalarOp::Eq => Ok(Value::Bool(false)),
+        ScalarOp::NotEq => Ok(Value::Bool(true)),
+        ScalarOp::Lt | ScalarOp::LtEq | ScalarOp::Gt | ScalarOp::GtEq => {
+            bail!("cannot compare values")
+        }
+        _ => unreachable!("fast scalar literal only handles comparison ops"),
+    }
+}
+
+fn eval_ordering_or_eq(op: ScalarOp, equal: bool, ordering: Ordering, reverse: bool) -> Value {
+    match op {
+        ScalarOp::Eq => Value::Bool(equal),
+        ScalarOp::NotEq => Value::Bool(!equal),
+        ScalarOp::Lt | ScalarOp::LtEq | ScalarOp::Gt | ScalarOp::GtEq => {
+            Value::Bool(apply_ordering(op, ordering, reverse))
+        }
+        _ => unreachable!("fast scalar literal only handles comparison ops"),
+    }
+}
+
+fn apply_ordering(op: ScalarOp, ordering: Ordering, reverse: bool) -> bool {
+    let ordering = if reverse {
+        ordering.reverse()
+    } else {
+        ordering
+    };
+    match op {
+        ScalarOp::Lt => ordering.is_lt(),
+        ScalarOp::LtEq => ordering.is_le(),
+        ScalarOp::Gt => ordering.is_gt(),
+        ScalarOp::GtEq => ordering.is_ge(),
+        _ => unreachable!("fast scalar literal only handles ordering ops"),
+    }
 }
 
 pub(crate) fn array_to_values(array: &dyn Array) -> Result<Vec<Value>> {

{rxgraph-0.2.0 → rxgraph-0.3.1}/crates/rxgraph/src/dsl/bind.rs

@@ -2,12 +2,13 @@ use anyhow::{Context, Result};
 
 use crate::{
     dsl::{
-        DslKernel, StateRow, StateValues, Value,
+        DslKernel, StateRow, StateValue, StateValues, Value,
         arrow_value::ColumnReader,
         eval::EvalCtx,
         expr::{ColumnRef, Expr},
+        ops::scalar::ScalarOp,
     },
-    graph::{Graph, GraphId, GraphRepo},
+    graph::{EDGE_DEST_COL, EDGE_SRC_COL, Graph, GraphId, GraphRepo, ID_COL},
 };
 
 #[derive(Debug)]
@@ -50,10 +51,14 @@ impl BoundKernel {
         self.visit.eval(ctx)?.truthy()
     }
 
-    pub(crate) fn next_state(&self, current: &[Value], ctx: &EvalCtx<'_>) -> Result<StateValues> {
+    pub(crate) fn next_state(
+        &self,
+        current: &[StateValue],
+        ctx: &EvalCtx<'_>,
+    ) -> Result<StateValues> {
         let mut next = current.iter().cloned().collect::<StateValues>();
         for (index, expr) in &self.next_state {
-            next[*index] = expr.eval(ctx)?;
+            next[*index] = StateValue::new(expr.eval(ctx)?);
         }
         Ok(next)
     }
@@ -62,11 +67,11 @@ impl BoundKernel {
         self.stop.eval(ctx)?.truthy()
     }
 
-    pub(crate) fn state_row(&self, state: &[Value]) -> StateRow {
+    pub(crate) fn state_row(&self, state: &[StateValue]) -> StateRow {
         self.names
             .iter()
             .cloned()
-            .zip(state.iter().cloned())
+            .zip(state.iter().map(StateValue::to_value))
             .collect()
     }
 }
@@ -89,8 +94,13 @@ impl BoundColumn {
             ColumnRef::SrcId => Self::SrcId,
             ColumnRef::DestId => Self::DestId,
             ColumnRef::EdgeId => Self::EdgeId,
+            ColumnRef::SrcField(name) if name == ID_COL => Self::SrcId,
             ColumnRef::SrcField(name) => Self::Src(ColumnReader::bind(&graph.repo.nodes, &name)?),
+            ColumnRef::DestField(name) if name == ID_COL => Self::DestId,
             ColumnRef::DestField(name) => Self::Dest(ColumnReader::bind(&graph.repo.nodes, &name)?),
+            ColumnRef::EdgeField(name) if name == ID_COL => Self::EdgeId,
+            ColumnRef::EdgeField(name) if name == EDGE_SRC_COL => Self::SrcId,
+            ColumnRef::EdgeField(name) if name == EDGE_DEST_COL => Self::DestId,
             ColumnRef::EdgeField(name) => Self::Edge(ColumnReader::bind(&graph.repo.edges, &name)?),
             ColumnRef::State(name) => state_index(names, &name)
                 .map(Self::State)
@@ -121,10 +131,31 @@ impl BoundColumn {
             Self::Src(reader) => reader.value(ctx.src as usize),
             Self::Dest(reader) => reader.value(ctx.dest as usize),
             Self::Edge(reader) => reader.value(ctx.edge as usize),
-            Self::State(index) => Ok(ctx.state[*index].clone()),
+            Self::State(index) => Ok(ctx.state[*index].to_value()),
             Self::MissingState => Ok(Value::Null),
         }
     }
+
+    pub(crate) fn eval_scalar_literal(
+        &self,
+        ctx: &EvalCtx<'_>,
+        op: ScalarOp,
+        literal: &Value,
+        reverse: bool,
+    ) -> Result<Option<Value>> {
+        match self {
+            Self::Src(reader) => reader.eval_scalar_literal(ctx.src as usize, op, literal, reverse),
+            Self::Dest(reader) => {
+                reader.eval_scalar_literal(ctx.dest as usize, op, literal, reverse)
+            }
+            Self::Edge(reader) => {
+                reader.eval_scalar_literal(ctx.edge as usize, op, literal, reverse)
+            }
+            Self::SrcId | Self::DestId | Self::EdgeId | Self::State(_) | Self::MissingState => {
+                Ok(None)
+            }
+        }
+    }
 }
 
 fn graph_id_value(id: GraphId<'_>) -> Result<Value> {
@@ -152,8 +183,8 @@ fn normalize_state(state: StateRow, names: &[String]) -> StateValues {
             state
                 .binary_search_by(|(key, _)| key.as_str().cmp(name))
                 .ok()
-                .map(|i| state[i].1.clone())
-                .unwrap_or(Value::Null)
+                .map(|i| StateValue::new(state[i].1.clone()))
+                .unwrap_or_else(|| StateValue::new(Value::Null))
         })
         .collect::<StateValues>()
 }

rxgraph-0.3.1/crates/rxgraph/src/dsl/eval.rs

@@ -0,0 +1,170 @@
+use anyhow::{Context, Result};
+
+use crate::{
+    dsl::{StateValue, Value, bind::BoundColumn, expr::Expr, ops::scalar::ScalarOp},
+    graph::{EdgeId, Graph, NodeId},
+};
+
+pub(crate) struct EvalCtx<'a> {
+    pub(crate) graph: &'a Graph,
+    pub(crate) src: NodeId,
+    pub(crate) dest: NodeId,
+    pub(crate) edge: EdgeId,
+    pub(crate) state: &'a [StateValue],
+    element: Option<&'a Value>,
+}
+
+impl<'a> EvalCtx<'a> {
+    pub(crate) fn new(
+        graph: &'a Graph,
+        src: NodeId,
+        dest: NodeId,
+        edge: EdgeId,
+        state: &'a [StateValue],
+    ) -> Self {
+        Self {
+            graph,
+            src,
+            dest,
+            edge,
+            state,
+            element: None,
+        }
+    }
+
+    pub(crate) fn with_state<'b>(&'b self, state: &'b [StateValue]) -> EvalCtx<'b> {
+        EvalCtx {
+            graph: self.graph,
+            src: self.src,
+            dest: self.dest,
+            edge: self.edge,
+            state,
+            element: self.element,
+        }
+    }
+
+    pub(crate) fn with_element<'b>(&'b self, element: &'b Value) -> EvalCtx<'b> {
+        EvalCtx {
+            graph: self.graph,
+            src: self.src,
+            dest: self.dest,
+            edge: self.edge,
+            state: self.state,
+            element: Some(element),
+        }
+    }
+}
+
+impl Expr<BoundColumn> {
+    pub(crate) fn eval(&self, ctx: &EvalCtx<'_>) -> Result<Value> {
+        match self {
+            Self::Column(column) => column.value(ctx),
+            Self::Element => ctx
+                .element
+                .cloned()
+                .context("pl.element() is only valid inside list.eval/list.filter"),
+            Self::Literal(value) => Ok(value.clone()),
+            Self::Alias(expr, _) => expr.eval(ctx),
+            Self::Ternary {
+                predicate,
+                truthy,
+                falsy,
+            } => {
+                if predicate.eval(ctx)?.truthy()? {
+                    truthy.eval(ctx)
+                } else {
+                    falsy.eval(ctx)
+                }
+            }
+            Self::Scalar(ScalarOp::And, args) => eval_and(args, ctx),
+            Self::Scalar(ScalarOp::Or, args) => eval_or(args, ctx),
+            Self::Scalar(op, args) => {
+                if let Some(value) = try_eval_scalar_fast_path(*op, args, ctx)? {
+                    return Ok(value);
+                }
+                let args = eval_args(args, ctx)?;
+                op.eval(&args)
+            }
+            Self::String(op, args) => {
+                let args = eval_args(args, ctx)?;
+                op.eval(&args)
+            }
+            Self::List(op, args) => op.eval_with_exprs(args, ctx),
+            Self::Struct(op, args) => op.eval_with_exprs(args, ctx),
+        }
+    }
+}
+
+fn eval_args(args: &[Expr<BoundColumn>], ctx: &EvalCtx<'_>) -> Result<Vec<Value>> {
+    args.iter().map(|expr| expr.eval(ctx)).collect()
+}
+
+fn eval_and(args: &[Expr<BoundColumn>], ctx: &EvalCtx<'_>) -> Result<Value> {
+    let left = expr_arg(args, 0)?;
+    let right = expr_arg(args, 1)?;
+    // Short circuit (optimization)
+    if !left.eval(ctx)?.truthy()? {
+        return Ok(Value::Bool(false));
+    }
+    Ok(Value::Bool(right.eval(ctx)?.truthy()?))
+}
+
+fn eval_or(args: &[Expr<BoundColumn>], ctx: &EvalCtx<'_>) -> Result<Value> {
+    let left = expr_arg(args, 0)?;
+    let right = expr_arg(args, 1)?;
+    // Short circuit (optimization)
+    if left.eval(ctx)?.truthy()? {
+        return Ok(Value::Bool(true));
+    }
+    Ok(Value::Bool(right.eval(ctx)?.truthy()?))
+}
+
+// Handles primitive column/literal comparisons without boxing column values (optimization).
+fn try_eval_scalar_fast_path(
+    op: ScalarOp,
+    args: &[Expr<BoundColumn>],
+    ctx: &EvalCtx<'_>,
+) -> Result<Option<Value>> {
+    if !matches!(
+        op,
+        ScalarOp::Eq
+            | ScalarOp::NotEq
+            | ScalarOp::Lt
+            | ScalarOp::LtEq
+            | ScalarOp::Gt
+            | ScalarOp::GtEq
+    ) {
+        return Ok(None);
+    }
+
+    let left = expr_arg(args, 0)?;
+    let right = expr_arg(args, 1)?;
+    if let (Some(column), Some(literal)) = (column_expr(left), literal_expr(right)) {
+        return column.eval_scalar_literal(ctx, op, literal, false);
+    }
+    if let (Some(literal), Some(column)) = (literal_expr(left), column_expr(right)) {
+        return column.eval_scalar_literal(ctx, op, literal, true);
+    }
+    Ok(None)
+}
+
+fn expr_arg(args: &[Expr<BoundColumn>], index: usize) -> Result<&Expr<BoundColumn>> {
+    args.get(index)
+        .with_context(|| format!("missing scalar op argument {index}"))
+}
+
+fn column_expr(expr: &Expr<BoundColumn>) -> Option<&BoundColumn> {
+    match expr {
+        Expr::Column(column) => Some(column),
+        Expr::Alias(expr, _) => column_expr(expr),
+        _ => None,
+    }
+}
+
+fn literal_expr(expr: &Expr<BoundColumn>) -> Option<&Value> {
+    match expr {
+        Expr::Literal(value) => Some(value),
+        Expr::Alias(expr, _) => literal_expr(expr),
+        _ => None,
+    }
+}