use std::collections::HashMap;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ProjectPathSegment {
Key(String),
Index(i64),
ArrayWildcard,
ArraySlice {
start: Option<i64>,
end: Option<i64>,
step: Option<i64>,
},
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SelectExpr {
Identity,
Current,
Field(String),
FieldQuoted(String),
Literal(Vec<u8>),
Object(ObjectSelect),
Array(ArraySelect),
MultiSelectHash(Vec<HashField>),
MultiSelectList(Vec<SelectExpr>),
Pipe(Box<SelectExpr>, Box<SelectExpr>),
Flatten(Box<SelectExpr>),
Sub(Box<SelectExpr>, Box<SelectExpr>),
Cmp {
op: CmpOp,
left: Box<SelectExpr>,
right: Box<SelectExpr>,
},
And(Box<SelectExpr>, Box<SelectExpr>),
Or(Box<SelectExpr>, Box<SelectExpr>),
Not(Box<SelectExpr>),
Call {
name: String,
args: Vec<SelectExpr>,
},
Expref(Box<SelectExpr>),
ObjectProjection(Box<SelectExpr>),
Paren(Box<SelectExpr>),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CmpOp {
Eq,
Ne,
Lt,
Le,
Gt,
Ge,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashField {
pub output_key: String,
pub expr: SelectExpr,
}
impl HashField {
pub fn new(output_key: impl Into<String>, expr: SelectExpr) -> Self {
Self {
output_key: output_key.into(),
expr,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ObjectSelect {
pub(crate) fields: HashMap<String, SelectExpr>,
}
impl ObjectSelect {
pub fn new() -> Self {
Self {
fields: HashMap::new(),
}
}
pub fn len(&self) -> usize {
self.fields.len()
}
pub fn is_empty(&self) -> bool {
self.fields.is_empty()
}
pub fn keys(&self) -> impl Iterator<Item = &str> {
self.fields.keys().map(|s| s.as_str())
}
pub fn get(&self, key: &str) -> Option<&SelectExpr> {
self.fields.get(key)
}
pub fn insert(&mut self, key: impl Into<String>, expr: SelectExpr) {
self.fields.insert(key.into(), expr);
}
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ArraySelect {
Each(Box<SelectExpr>),
Indices(HashMap<i64, SelectExpr>),
Slice {
start: Option<i64>,
end: Option<i64>,
step: Option<i64>,
each: Box<SelectExpr>,
},
Filter {
pred: Box<SelectExpr>,
each: Box<SelectExpr>,
},
}
impl SelectExpr {
pub fn identity() -> Self {
Self::Identity
}
pub fn pipe(left: SelectExpr, right: SelectExpr) -> Self {
SelectExpr::Pipe(Box::new(left), Box::new(right))
}
pub fn flatten(inner: SelectExpr) -> Self {
SelectExpr::Flatten(Box::new(inner))
}
}
pub fn resolve_index(index: i64, len: usize) -> Option<usize> {
if index >= 0 {
let i = index as usize;
if i < len {
Some(i)
} else {
None
}
} else {
let n = (-index) as usize;
if n == 0 || n > len {
None
} else {
Some(len - n)
}
}
}
pub fn resolve_slice(
len: usize,
start: Option<i64>,
end: Option<i64>,
step: Option<i64>,
) -> Vec<usize> {
let step = step.unwrap_or(1);
if step == 0 {
return Vec::new();
}
let len_i = len as i64;
let mut s = start.unwrap_or(if step > 0 { 0 } else { len_i - 1 });
let mut e = end.unwrap_or(if step > 0 { len_i } else { -len_i - 1 });
if s < 0 {
s += len_i;
}
if e < 0 {
e += len_i;
}
if step > 0 {
s = s.clamp(0, len_i);
e = e.clamp(0, len_i);
let mut out = Vec::new();
let mut i = s;
while i < e {
out.push(i as usize);
i += step;
}
out
} else {
s = s.clamp(-1, len_i - 1);
e = e.clamp(-1, len_i - 1);
let mut out = Vec::new();
let mut i = s;
while i > e {
if i >= 0 && i < len_i {
out.push(i as usize);
}
i += step;
}
out
}
}