Trait DataframeRowsIterExt 

pub trait DataframeRowsIterExt<'a> {
    // Required methods
    fn rows_iter<T>(
        &'a self,
    ) -> PolarsResult<Box<dyn Iterator<Item = PolarsResult<T>> + 'a>>
       where T: FromDataFrameRow<'a>;
    fn rows_iter_with_columns<T>(
        &'a self,
        build_fn: impl FnOnce(&mut T::Builder) -> &mut T::Builder,
    ) -> PolarsResult<Box<dyn Iterator<Item = PolarsResult<T>> + 'a>>
       where T: FromDataFrameRow<'a>;
    fn scalar_iter<T>(
        &'a self,
        column_name: &'a str,
    ) -> PolarsResult<impl Iterator<Item = PolarsResult<T>> + 'a>
       where T: IterFromColumn<'a> + 'a;
}

Required Methods

fn rows_iter<T>( &'a self, ) -> PolarsResult<Box<dyn Iterator<Item = PolarsResult<T>> + 'a>>

where T: FromDataFrameRow<'a>,

fn rows_iter_with_columns<T>( &'a self, build_fn: impl FnOnce(&mut T::Builder) -> &mut T::Builder, ) -> PolarsResult<Box<dyn Iterator<Item = PolarsResult<T>> + 'a>>

where T: FromDataFrameRow<'a>,

fn scalar_iter<T>( &'a self, column_name: &'a str, ) -> PolarsResult<impl Iterator<Item = PolarsResult<T>> + 'a>

where T: IterFromColumn<'a> + 'a,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> DataframeRowsIterExt<'a> for DataFrame

fn rows_iter<T>( &'a self, ) -> PolarsResult<Box<dyn Iterator<Item = PolarsResult<T>> + 'a>>

where T: FromDataFrameRow<'a>,

Creates a row iterator for this DataFrame with static column names defined in row struct

use polars::prelude::*;
use polars_rows_iter::*;

   #[derive(Debug, FromDataFrameRow)]
   #[derive(PartialEq)] // for assert_eq
   struct MyRow<'a>
   {
       #[column("col_a")]
       a: i32,
       // the column name defaults to the field name if no explicit name given
       col_b: &'a str,
       col_c: String,
       #[column("col_d")]
       optional: Option<f64>
   }
   
   let df = df!(
           "col_a" => [1i32, 2, 3, 4, 5],
           "col_b" => ["a", "b", "c", "d", "e"],
           "col_c" => ["A", "B", "C", "D", "E"],
           "col_d" => [Some(1.0f64), None, None, Some(2.0), Some(3.0)]
       ).unwrap();
   
   let rows_iter = df.rows_iter::<MyRow>().unwrap(); // ready to use row iterator
   // collect to vector for assert_eq
   let rows_vec = rows_iter.collect::<PolarsResult<Vec<MyRow>>>().unwrap();
   
   assert_eq!(
       rows_vec,
       [
           MyRow { a: 1, col_b: "a", col_c: "A".to_string(), optional: Some(1.0) },
           MyRow { a: 2, col_b: "b", col_c: "B".to_string(), optional: None },
           MyRow { a: 3, col_b: "c", col_c: "C".to_string(), optional: None },
           MyRow { a: 4, col_b: "d", col_c: "D".to_string(), optional: Some(2.0) },
           MyRow { a: 5, col_b: "e", col_c: "E".to_string(), optional: Some(3.0) },
       ]
   );

fn rows_iter_with_columns<T>( &'a self, build_fn: impl FnOnce(&mut T::Builder) -> &mut T::Builder, ) -> PolarsResult<Box<dyn Iterator<Item = PolarsResult<T>> + 'a>>

where T: FromDataFrameRow<'a>,

Creates a row iterator for this DataFrame with custom column names, which can be defined over the lambda function for every struct field. If no custom column name for a field is given, the column name falls back to the statically defined one.

use polars::prelude::*;
use polars_rows_iter::*;

const ID: &str = "id";

#[derive(Debug, FromDataFrameRow)]
#[derive(PartialEq)] // for assert_eq
struct MyRow<'a> {
    #[column(ID)]
    id: i32,
    value_b: &'a str,
    value_c: String,
    optional: Option<f64>,
}

    let df = df!(
        "id" => [1i32, 2, 3, 4, 5],
        "col_b" => ["a", "b", "c", "d", "e"],
        "col_c" => ["A", "B", "C", "D", "E"],
        "col_d" => [Some(1.0f64), None, None, Some(2.0), Some(3.0)]
    ).unwrap();

    let value_b_column_name = "col_b".to_string();
    let value_c_column_name = "col_c";

    let rows_iter = df.rows_iter_with_columns::<MyRow>(|columns| {
        columns
            .value_b(&value_b_column_name)
            .value_c(value_c_column_name)
            .optional("col_d")
    }).unwrap();

    // collect to vector for assert_eq
    let rows_vec = rows_iter.collect::<PolarsResult<Vec<MyRow>>>().unwrap();
   
    assert_eq!(
        rows_vec,
        [
            MyRow { id: 1, value_b: "a", value_c: "A".to_string(), optional: Some(1.0) },
            MyRow { id: 2, value_b: "b", value_c: "B".to_string(), optional: None },
            MyRow { id: 3, value_b: "c", value_c: "C".to_string(), optional: None },
            MyRow { id: 4, value_b: "d", value_c: "D".to_string(), optional: Some(2.0) },
            MyRow { id: 5, value_b: "e", value_c: "E".to_string(), optional: Some(3.0) },
        ]
    );

fn scalar_iter<T>( &'a self, column_name: &'a str, ) -> PolarsResult<impl Iterator<Item = PolarsResult<T>> + 'a>

where T: IterFromColumn<'a> + 'a,

Creates an iterator for a single column in the DataFrame

This is a simpler alternative to rows_iter when you only need to iterate over one column. The type parameter T specifies the Rust type to convert column values to.

use polars::prelude::*;
use polars_rows_iter::*;

let df = df!(
    "col_a" => [1i32, 2, 3, 4, 5],
    "col_b" => ["a", "b", "c", "d", "e"],
    "col_c" => [Some("A"), Some("B"), None, None, Some("E")],
).unwrap();

// Iterate over a column with non-nullable values
let values_a = df.scalar_iter::<i32>("col_a")
    .unwrap()
    .collect::<PolarsResult<Vec<i32>>>()
    .unwrap();
assert_eq!(values_a, [1, 2, 3, 4, 5]);

// Iterate over a column with borrowed string values
let values_b = df.scalar_iter::<&str>("col_b")
    .unwrap()
    .collect::<PolarsResult<Vec<&str>>>()
    .unwrap();
assert_eq!(values_b, ["a", "b", "c", "d", "e"]);

// Iterate over a column with optional values
let values_c = df.scalar_iter::<Option<String>>("col_c")
    .unwrap()
    .collect::<PolarsResult<Vec<Option<String>>>>()
    .unwrap();
assert_eq!(
    values_c,
    [Some("A".to_string()), Some("B".to_string()), None, None, Some("E".to_string())]
);

Implementors