Struct csvsc::prelude::Reducer [−][src]
An uncomplicated builder of arguments for InputStream’s reduce method.
RowStream::reduce()
accepts a vector of Aggregates. Use this struct to
define them using the methods listed below.
Example
use csvsc::prelude::*; use encoding::all::UTF_8; InputStreamBuilder::from_paths(&["test/assets/1.csv"]).unwrap().build().unwrap() .reduce(vec![ Reducer::with_name("rows").count(), ]) .into_iter();
Implementations
impl Reducer
[src]
pub fn with_name(name: &str) -> Reducer
[src]
Start building an aggregate by giving it a column name. This column will be present in the output row and will contain the aggregated value.
pub fn count(self) -> Box<dyn Aggregate>
[src]
Creates an aggregate that counts all Ok rows of the stream.
Example
Reducer::with_name("rows").count();
pub fn custom<'a, A>(reducer: A) -> Box<dyn Aggregate + 'a> where
A: Aggregate + 'a,
[src]
A: Aggregate + 'a,
A custom reducer, this method is not strictrly needed because you can
just pass Box::new(YourReducer::new())
to .reduce()
but it exists
for consistency.
Example
use csvsc::prelude::*; #[derive(Debug)] struct MyAggregate { colname: String, state: (f64, f64), } impl Aggregate for MyAggregate { fn update(&mut self, headers: &Headers, row: &Row) -> csvsc::error::Result<()> { let x: f64 = headers.get_field(row, "x").unwrap().parse().unwrap(); let y: f64 = headers.get_field(row, "y").unwrap().parse().unwrap(); self.state.0 += x; self.state.1 += y; Ok(()) } fn colname(&self) -> &str { &self.colname } fn value(&self) -> String { format!("{},{}", self.state.0, self.state.1) } } Reducer::custom(MyAggregate { colname: String::from("custom"), state: (0.0, 0.0), });
pub fn of_column(self, name: &str) -> Reducer
[src]
Most aggregates need a source column, use this string as source column name.
Example
Reducer::with_name("richest").of_column("income").max(0.0);
pub fn average(self) -> Option<Box<dyn Aggregate>>
[src]
Compute the average of the values in the specified column, if a value cannot be parsed to f64 returns an error row.
Example
Reducer::with_name("average").of_column("income").average();
pub fn last(self, init: &str) -> Option<Box<dyn Aggregate>>
[src]
A simple reducer that takes the last value it sees or uses the argument given as default.
Useful for just keeping a column used for grouping in an aggregate.
Example
Reducer::with_name("name").of_column("name").last("-");
pub fn max<'a, T>(self, init: T) -> Option<Box<dyn Aggregate + 'a>> where
T: Display + Debug + PartialOrd + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
[src]
T: Display + Debug + PartialOrd + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
Return the maximum of the specified column’s values and use init
as
default if the value cannot be parsed to T.
init
is both used to specify the type to parse to and the default.
A sensible value for it would be a number smaller than all the values
you expect from your data
Example
use std::f64; Reducer::with_name("max").of_column("height").max(f64::NEG_INFINITY);
pub fn min<'a, T>(self, init: T) -> Option<Box<dyn Aggregate + 'a>> where
T: Display + Debug + PartialOrd + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
[src]
T: Display + Debug + PartialOrd + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
Return the minimum of the specified column’s values and use init
as
default if the value cannot be parsed to T.
init
is both used to specify the type to parse to and the default.
A sensible value for it would be a number higher than all the values
you expect from your data.
Example
use std::f64; Reducer::with_name("min").of_column("height").min(f64::INFINITY);
pub fn sum<'a, T>(self, init: T) -> Option<Box<dyn Aggregate + 'a>> where
T: Display + Debug + AddAssign + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
[src]
T: Display + Debug + AddAssign + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
Return the sum of the specified column’s values and use init
as
default if the value cannot be parsed to T.
init
is both used to specify the type to parse to and the default.
A sensible value for it would be 0.0
Example
Reducer::with_name("sum").of_column("height").sum(0.0);
pub fn mul<'a, T>(self, init: T) -> Option<Box<dyn Aggregate + 'a>> where
T: Display + Debug + MulAssign + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
[src]
T: Display + Debug + MulAssign + FromStr + Copy + 'a,
<T as FromStr>::Err: Debug,
Return the product of the specified column’s values and use init
as
default if the value cannot be parsed to T.
init
is both used to specify the type to parse to and the default.
A sensible value for it would be 1.0
Example
Reducer::with_name("product").of_column("height").mul(1.0);
pub fn with_closure<'a, F, C>(
self,
f: F,
init: C
) -> Option<Box<dyn Aggregate + 'a>> where
F: FnMut(C, &str) -> Result<C> + 'a,
C: Display + 'a,
[src]
self,
f: F,
init: C
) -> Option<Box<dyn Aggregate + 'a>> where
F: FnMut(C, &str) -> Result<C> + 'a,
C: Display + 'a,
Use a closure to compute an aggregate for the specified column.
Here you have absolute freedom.
The first argument of the closure is the accumulator, the second is the
current row’s value. init
will be used as starter.
Example
Reducer::with_name("closure").of_column("col").with_closure(|acc, cur| { Ok(acc + cur.parse::<i32>().unwrap()) }, 0).unwrap();
Auto Trait Implementations
impl RefUnwindSafe for Reducer
impl Send for Reducer
impl Sync for Reducer
impl Unpin for Reducer
impl UnwindSafe for Reducer
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,