Struct csv_pipeline::Pipeline

pub struct Pipeline<'a> {
    pub headers: Headers,
    /* private fields */
}

The main thing

Fields

headers: Headers

Implementations

impl<'a> Pipeline<'a>

pub fn from_reader<R: Read + 'a>(reader: Reader<R>) -> Result<Self, Error>

pub fn from_path<P: AsRef<Path>>(file_path: P) -> Result<Self, Error>

Create a pipeline from a CSV or TSV file.

pub fn add_col<F>(self, name: &str, get_value: F) -> Selfwhere
    F: FnMut(&Headers, &Row) -> Result<String, Error> + 'a,

Adds a column with values computed from the closure for each row.

Example

use csv_pipeline::Pipeline;

Pipeline::from_path("test/AB.csv")
  .unwrap()
  .add_col("C", |headers, row| {
    Ok("1".to_string())
  });

pub fn map<F>(self, get_row: F) -> Selfwhere
    F: FnMut(&Headers, Row) -> Result<Row, Error> + 'a,

Maps each row.

Example

use csv_pipeline::Pipeline;

let csv = Pipeline::from_path("test/AB.csv")
  .unwrap()
  .map(|headers, row| {
    Ok(row.into_iter().map(|field| field.to_string() + "0").collect())
  })
  .collect_into_string()
  .unwrap();

assert_eq!(csv, "A,B\n10,20\n"
);

pub fn map_col<F>(self, col: &str, get_value: F) -> Selfwhere
    F: FnMut(&str) -> Result<String, Error> + 'a,

Maps each field of a column.

Example

use csv_pipeline::Pipeline;

let csv = Pipeline::from_path("test/Countries.csv")
  .unwrap()
  .map_col("Country", |field| Ok(field.to_uppercase()))
  .collect_into_string()
  .unwrap();

assert_eq!(
  csv,
  "ID,Country\n\
    1,NORWAY\n\
    2,TUVALU\n"
);

pub fn rename_col(self, from: &str, to: &str) -> Self

Panics if a new name already exists

Example

use csv_pipeline::Pipeline;

let csv = Pipeline::from_path("test/AB.csv")
  .unwrap()
  .rename_col("A", "X")
  .collect_into_string()
  .unwrap();

assert_eq!(csv, "X,B\n1,2\n");

pub fn rename_cols<R>(self, get_name: R) -> Selfwhere
    R: FnMut(usize, &str) -> &str,

Panics if a new name already exists

Example

use csv_pipeline::Pipeline;

let csv = Pipeline::from_path("test/AB.csv")
  .unwrap()
  .rename_cols(|i, name| {
    match name {
      "A" => "X",
      name => name,
    }
  })
  .collect_into_string()
  .unwrap();

assert_eq!(csv, "X,B\n1,2\n");

pub fn transform_into<T>(self, get_transformers: T) -> Selfwhere
    T: FnMut() -> Vec<Box<dyn Transform>> + 'a,

Group and reduce rows into. Panics if the transform results in duplicate column names.

Example

use csv_pipeline::Pipeline;

let csv = Pipeline::from_path("test/AB.csv")
  .unwrap()
  .rename_cols(|i, name| {
    match name {
      "A" => "X",
      name => name,
    }
  })
  .collect_into_string()
  .unwrap();

assert_eq!(csv, "X,B\n1,2\n");

pub fn validate<F>(self, get_row: F) -> Selfwhere
    F: FnMut(&Headers, &Row) -> Result<(), Error> + 'a,

pub fn validate_col<F>(self, name: &str, get_row: F) -> Selfwhere
    F: FnMut(&str) -> Result<(), Error> + 'a,

pub fn flush(self, target: impl Target + 'a) -> Self

Write to the specified Target.

Example

use csv_pipeline::{Pipeline, Target};

let mut csv = String::new();
Pipeline::from_path("test/AB.csv")
  .unwrap()
  .flush(Target::string(&mut csv))
  .run()
  .unwrap();

assert_eq!(csv, "A,B\n1,2\n");

pub fn build(self) -> PipelineIter<'a>

Turn the pipeline into an iterator. You can also do this using pipeline.into_iter().

pub fn run(self) -> Result<(), Error>

Shorthand for .build().run().

pub fn collect_into_string(self) -> Result<String, Error>

Trait Implementations

impl<'a> IntoIterator for Pipeline<'a>

type Item = Result<StringRecord, Error>

The type of the elements being iterated over.

type IntoIter = PipelineIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.