Struct CsvReadOptions

pub struct CsvReadOptions {

    pub path: Option<PathBuf>,
    pub rechunk: bool,
    pub n_threads: Option<usize>,
    pub low_memory: bool,
    pub n_rows: Option<usize>,
    pub row_index: Option<RowIndex>,
    pub columns: Option<Arc<[PlSmallStr]>>,
    pub projection: Option<Arc<Vec<usize>>>,
    pub schema: Option<Arc<Schema<DataType>>>,
    pub schema_overwrite: Option<Arc<Schema<DataType>>>,
    pub dtype_overwrite: Option<Arc<Vec<DataType>>>,
    pub parse_options: Arc<CsvParseOptions>,
    pub has_header: bool,
    pub chunk_size: usize,
    pub skip_rows: usize,
    pub skip_lines: usize,
    pub skip_rows_after_header: usize,
    pub infer_schema_length: Option<usize>,
    pub raise_if_empty: bool,
    pub ignore_errors: bool,
    pub fields_to_cast: Vec<Field>,
}

Available on crate feature polars-io only.

Fields

path: Option<PathBuf>

rechunk: bool

n_threads: Option<usize>

low_memory: bool

n_rows: Option<usize>

row_index: Option<RowIndex>

columns: Option<Arc<[PlSmallStr]>>

projection: Option<Arc<Vec<usize>>>

schema: Option<Arc<Schema<DataType>>>

schema_overwrite: Option<Arc<Schema<DataType>>>

dtype_overwrite: Option<Arc<Vec<DataType>>>

parse_options: Arc<CsvParseOptions>

has_header: bool

chunk_size: usize

skip_rows: usize

Skip rows according to the CSV spec.

skip_lines: usize

Skip lines according to newline char (e.g. escaping will be ignored)

skip_rows_after_header: usize

infer_schema_length: Option<usize>

raise_if_empty: bool

ignore_errors: bool

fields_to_cast: Vec<Field>

Implementations

impl CsvReadOptions

pub fn get_parse_options(&self) -> Arc<CsvParseOptions>

pub fn with_path<P>(self, path: Option<P>) -> CsvReadOptions

where P: Into<PathBuf>,

pub fn with_rechunk(self, rechunk: bool) -> CsvReadOptions

Whether to makes the columns contiguous in memory.

pub fn with_n_threads(self, n_threads: Option<usize>) -> CsvReadOptions

Number of threads to use for reading. Defaults to the size of the polars thread pool.

pub fn with_low_memory(self, low_memory: bool) -> CsvReadOptions

Reduce memory consumption at the expense of performance

pub fn with_n_rows(self, n_rows: Option<usize>) -> CsvReadOptions

Limits the number of rows to read.

pub fn with_row_index(self, row_index: Option<RowIndex>) -> CsvReadOptions

Adds a row index column.

pub fn with_columns(self, columns: Option<Arc<[PlSmallStr]>>) -> CsvReadOptions

Which columns to select.

pub fn with_projection( self, projection: Option<Arc<Vec<usize>>>, ) -> CsvReadOptions

Which columns to select denoted by their index. The index starts from 0 (i.e. [0, 4] would select the 1st and 5th column).

pub fn with_schema( self, schema: Option<Arc<Schema<DataType>>>, ) -> CsvReadOptions

Set the schema to use for CSV file. The length of the schema must match the number of columns in the file. If this is None, the schema is inferred from the file.

pub fn with_schema_overwrite( self, schema_overwrite: Option<Arc<Schema<DataType>>>, ) -> CsvReadOptions

Overwrites the data types in the schema by column name.

pub fn with_dtype_overwrite( self, dtype_overwrite: Option<Arc<Vec<DataType>>>, ) -> CsvReadOptions

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 with_parse_options( self, parse_options: CsvParseOptions, ) -> CsvReadOptions

Sets the CSV parsing options. See map_parse_options for an easier way to mutate them in-place.

pub fn with_has_header(self, has_header: bool) -> CsvReadOptions

Sets whether the CSV file has a header row.

pub fn with_chunk_size(self, chunk_size: usize) -> CsvReadOptions

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

pub fn with_skip_rows(self, skip_rows: usize) -> CsvReadOptions

Start reading after skip_rows rows. The header will be parsed at this offset. Note that we respect CSV escaping/comments when skipping rows. If you want to skip by newline char only, use skip_lines.

pub fn with_skip_lines(self, skip_lines: usize) -> CsvReadOptions

Start reading after skip_lines lines. The header will be parsed at this offset. Note that CSV escaping will not be respected when skipping lines. If you want to skip valid CSV rows, use skip_rows.

pub fn with_skip_rows_after_header( self, skip_rows_after_header: usize, ) -> CsvReadOptions

Number of rows to skip after the header row.

pub fn with_infer_schema_length( self, infer_schema_length: Option<usize>, ) -> CsvReadOptions

Number of rows to use for schema inference. Pass None to use all rows.

pub fn with_raise_if_empty(self, raise_if_empty: bool) -> CsvReadOptions

Whether to raise an error if the frame is empty. By default an empty DataFrame is returned.

pub fn with_ignore_errors(self, ignore_errors: bool) -> CsvReadOptions

Continue with next batch when a ParserError is encountered.

pub fn map_parse_options<F>(self, map_func: F) -> CsvReadOptions

where F: Fn(CsvParseOptions) -> CsvParseOptions,

Apply a function to the parse options.

impl CsvReadOptions

pub fn try_into_reader_with_file_path( self, path: Option<PathBuf>, ) -> Result<CsvReader<File>, PolarsError>

Creates a CSV reader using a file path.

Panics

If both self.path and the path parameter are non-null. Only one of them is to be non-null.

pub fn into_reader_with_file_handle<R>(self, reader: R) -> CsvReader<R>

where R: MmapBytesReader,

Creates a CSV reader using a file handle.

impl CsvReadOptions

pub fn update_with_inference_result( &mut self, si_result: &SchemaInferenceResult, )

Note: This does not update the schema from the inference result.

Trait Implementations

impl Clone for CsvReadOptions

fn clone(&self) -> CsvReadOptions

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CsvReadOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for CsvReadOptions

fn default() -> CsvReadOptions

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CsvReadOptions

fn deserialize<__D>( __deserializer: __D, ) -> Result<CsvReadOptions, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CsvReadOptions

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CsvReadOptions

fn eq(&self, other: &CsvReadOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CsvReadOptions

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CsvReadOptions

impl StructuralPartialEq for CsvReadOptions