Struct polars::prelude::CsvReader

pub struct CsvReader<'a, R> where
    R: MmapBytesReader,  { /* fields omitted */ }

Create a new DataFrame by reading a csv file.

Example

use polars_core::prelude::*;
use polars_io::prelude::*;
use std::fs::File;

fn example() -> Result<DataFrame> {
    CsvReader::from_path("iris_csv")?
            .infer_schema(None)
            .has_header(true)
            .finish()
}

Implementations

impl<'a, R> CsvReader<'a, R> where
    R: 'a + MmapBytesReader, 

pub fn with_chunk_size(self, chunk_size: usize) -> CsvReader<'a, R>

Sets the chunk size used by the parser. This influences performance

pub fn with_encoding(self, enc: CsvEncoding) -> CsvReader<'a, R>

Sets the CsvEncoding

pub fn with_stop_after_n_rows(self, num_rows: Option<usize>) -> CsvReader<'a, R>

Try to stop parsing when n rows are parsed. During multithreaded parsing the upper bound n cannot be guaranteed.

pub fn with_ignore_parser_errors(self, ignore: bool) -> CsvReader<'a, R>

Continue with next batch when a ParserError is encountered.

pub fn with_schema(self, schema: &'a Schema) -> CsvReader<'a, R>

Set the CSV file’s schema. This only accepts datatypes that are implemented in the csv parser and expects a complete Schema.

It is recommended to use with_dtypes instead.

pub fn with_skip_rows(self, skip_rows: usize) -> CsvReader<'a, R>

Skip the first n rows during parsing.

pub fn with_rechunk(self, rechunk: bool) -> CsvReader<'a, R>

Rechunk the DataFrame to contiguous memory after the CSV is parsed.

pub fn has_header(self, has_header: bool) -> CsvReader<'a, R>

Set whether the CSV file has headers

pub fn with_delimiter(self, delimiter: u8) -> CsvReader<'a, R>

Set the CSV file’s column delimiter as a byte character

pub fn with_comment_char(self, comment_char: Option<u8>) -> CsvReader<'a, R>

Set the comment character. Lines starting with this character will be ignored.

pub fn with_null_values(
    self,
    null_values: Option<NullValues>
) -> CsvReader<'a, R>

Set values that will be interpreted as missing/ null.

pub fn with_dtypes(self, schema: Option<&'a Schema>) -> CsvReader<'a, R>

Overwrite the schema with the dtypes in this given Schema. The given schema may be a subset of the total schema.

pub fn with_dtypes_slice(
    self,
    dtypes: Option<&'a [DataType]>
) -> CsvReader<'a, R>

Overwrite the dtypes in the schema in the order of the slice that’s given. This is useful if you don’t know the column names beforehand

pub fn infer_schema(self, max_records: Option<usize>) -> CsvReader<'a, R>

Set the CSV reader to infer the schema of the file

Arguments

• max_records - Maximum number of rows read for schema inference. Setting this to None will do a full table scan (slow).

pub fn with_projection(
    self,
    projection: Option<Vec<usize, Global>>
) -> CsvReader<'a, R>

Set the reader’s column projection. This counts from 0, meaning that vec![0, 4] would select the 1st and 5th column.

pub fn with_columns(
    self,
    columns: Option<Vec<String, Global>>
) -> CsvReader<'a, R>

Columns to select/ project

pub fn with_n_threads(self, n: Option<usize>) -> CsvReader<'a, R>

Set the number of threads used in CSV reading. The default uses the number of cores of your cpu.

Note that this only works if this is initialized with CsvReader::from_path. Note that the number of cores is the maximum allowed number of threads.

pub fn with_path<P>(self, path: Option<P>) -> CsvReader<'a, R> where
    P: Into<PathBuf>, 

The preferred way to initialize this builder. This allows the CSV file to be memory mapped and thereby greatly increases parsing performance.

pub fn sample_size(self, size: usize) -> CsvReader<'a, R>

Sets the size of the sample taken from the CSV file. The sample is used to get statistic about the file. These statistics are used to try to optimally allocate up front. Increasing this may improve performance.

pub fn low_memory(self, toggle: bool) -> CsvReader<'a, R>

Reduce memory consumption at the expense of performance

pub fn with_predicate(
    self,
    predicate: Option<Arc<dyn PhysicalIoExpr + 'static>>
) -> CsvReader<'a, R>

pub fn with_aggregate(
    self,
    aggregate: Option<&'a [ScanAggregation]>
) -> CsvReader<'a, R>

impl<'a> CsvReader<'a, File>

pub fn from_path<P>(path: P) -> Result<CsvReader<'a, File>, PolarsError> where
    P: Into<PathBuf>, 

This is the recommended way to create a csv reader as this allows for fastest parsing.

Trait Implementations

impl<'a, R> SerReader<R> for CsvReader<'a, R> where
    R: MmapBytesReader, 

pub fn new(reader: R) -> CsvReader<'a, R>

Create a new CsvReader from a file/ stream

pub fn finish(self) -> Result<DataFrame, PolarsError>

Read the file and create the DataFrame.

fn set_rechunk(self, _rechunk: bool) -> Self

Rechunk to a single chunk after Reading file.