# `Explorer.Backend.DataFrame`
[🔗](https://github.com/elixir-nx/explorer/blob/v0.12.0/lib/explorer/backend/data_frame.ex#L1)

The behaviour for DataFrame backends.

# `basic_types`

```elixir
@type basic_types() :: float() | integer() | String.t() | Date.t() | DateTime.t()
```

# `column_name`

```elixir
@type column_name() :: String.t()
```

# `columns_for_io`

```elixir
@type columns_for_io() :: [column_name()] | [pos_integer()] | nil
```

# `compact_level`

```elixir
@type compact_level() :: option(:oldest | :newest)
```

# `compression`

```elixir
@type compression() :: {algorithm :: option(atom()), level :: option(integer())}
```

# `df`

```elixir
@type df() :: Explorer.DataFrame.t()
```

# `dtype`

```elixir
@type dtype() :: Explorer.Series.dtype()
```

# `dtypes`

```elixir
@type dtypes() :: %{required(column_name()) => dtype()}
```

# `fs_entry`

```elixir
@type fs_entry() :: Explorer.DataFrame.fs_entry()
```

# `io_dtypes`

```elixir
@type io_dtypes() :: [{column_name(), dtype()}]
```

# `io_result`

```elixir
@type io_result(t) :: {:ok, t} | {:error, Exception.t()}
```

# `lazy_series`

```elixir
@type lazy_series() :: Explorer.Backend.LazySeries.t()
```

# `mutate_value`

```elixir
@type mutate_value() ::
  series()
  | basic_types()
  | [basic_types()]
  | (df() -> series() | basic_types() | [basic_types()])
```

# `ok_result`

```elixir
@type ok_result() :: :ok | {:error, Exception.t()}
```

# `option`

```elixir
@type option(type) :: type | nil
```

# `query_frame`

```elixir
@type query_frame() :: Explorer.Backend.QueryFrame.t()
```

# `quote_style`

```elixir
@type quote_style() :: :necessary | :always | :non_numeric | :never
```

# `result`

```elixir
@type result(t) :: {:ok, t} | {:error, term()}
```

# `series`

```elixir
@type series() :: Explorer.Series.t()
```

# `t`

```elixir
@type t() :: struct()
```

# `collect`

```elixir
@callback collect(df()) :: df()
```

# `concat_columns`

```elixir
@callback concat_columns([df()], out_df :: df()) :: df()
```

# `concat_rows`

```elixir
@callback concat_rows([df()], out_df :: df()) :: df()
```

# `correlation`

```elixir
@callback correlation(df(), out_df :: df(), method :: atom()) :: df()
```

# `covariance`

```elixir
@callback covariance(df(), out_df :: df(), ddof :: integer()) :: df()
```

# `distinct`

```elixir
@callback distinct(df(), out_df :: df(), columns :: [column_name()]) :: df()
```

# `drop_nil`

```elixir
@callback drop_nil(df(), columns :: [column_name()]) :: df()
```

# `dummies`

```elixir
@callback dummies(df(), out_df :: df(), columns :: [column_name()]) :: df()
```

# `dump_csv`

```elixir
@callback dump_csv(
  df(),
  header? :: boolean(),
  delimiter :: String.t(),
  quote_style :: quote_style()
) :: io_result(binary())
```

# `dump_ipc`

```elixir
@callback dump_ipc(df(), compression()) :: io_result(binary())
```

# `dump_ipc_record_batch`

```elixir
@callback dump_ipc_record_batch(df(), integer(), compression(), compact_level()) ::
  io_result([binary()])
```

# `dump_ipc_schema`

```elixir
@callback dump_ipc_schema(df(), compact_level()) :: io_result(binary())
```

# `dump_ipc_stream`

```elixir
@callback dump_ipc_stream(df(), compression()) :: io_result(binary())
```

# `dump_ndjson`

```elixir
@callback dump_ndjson(df()) :: io_result(binary())
```

# `dump_parquet`

```elixir
@callback dump_parquet(df(), compression()) :: io_result(binary())
```

# `estimated_size`

```elixir
@callback estimated_size(df()) :: integer()
```

# `explode`

```elixir
@callback explode(df(), out_df :: df(), columns :: [column_name()]) :: df()
```

# `filter_with`

```elixir
@callback filter_with(df(), out_df :: df(), lazy_series()) :: df()
```

# `from_csv`

```elixir
@callback from_csv(
  entry :: fs_entry(),
  io_dtypes(),
  delimiter :: String.t(),
  nil_values :: [String.t()],
  skip_rows :: integer(),
  skip_rows_after_header :: integer(),
  header? :: boolean(),
  encoding :: String.t(),
  max_rows :: option(integer()),
  columns :: columns_for_io(),
  infer_schema_length :: option(integer()),
  parse_dates :: boolean(),
  eol_delimiter :: option(String.t()),
  quote_delimiter :: option(String.t())
) :: io_result(df())
```

# `from_ipc`

```elixir
@callback from_ipc(
  entry :: fs_entry(),
  columns :: columns_for_io()
) :: io_result(df())
```

# `from_ipc_stream`

```elixir
@callback from_ipc_stream(
  filename :: fs_entry(),
  columns :: columns_for_io()
) :: io_result(df())
```

# `from_ndjson`

```elixir
@callback from_ndjson(
  filename :: fs_entry(),
  infer_schema_length :: integer(),
  batch_size :: integer()
) :: io_result(df())
```

# `from_parquet`

```elixir
@callback from_parquet(
  entry :: fs_entry(),
  max_rows :: option(integer()),
  columns :: columns_for_io(),
  rechunk :: boolean()
) :: io_result(df())
```

# `from_query`

```elixir
@callback from_query(
  Adbc.Connection.t(),
  query :: String.t(),
  params :: [term()]
) :: result(df())
```

# `from_series`

```elixir
@callback from_series([{binary(), Series.t()}]) :: df()
```

# `from_tabular`

```elixir
@callback from_tabular(Table.Reader.t(), io_dtypes()) :: df()
```

# `head`

```elixir
@callback head(df(), rows :: integer()) :: df()
```

# `inspect`

```elixir
@callback inspect(df(), opts :: Inspect.Opts.t()) :: Inspect.Algebra.t()
```

# `join`

```elixir
@callback join(
  [df()],
  out_df :: df(),
  on :: [{column_name(), column_name()}],
  how :: :left | :inner | :outer | :right | :cross,
  nulls_equal :: boolean()
) :: df()
```

# `join_asof`

```elixir
@callback join_asof(
  [df()],
  out_df :: df(),
  on :: [{column_name(), column_name()}],
  by :: [{column_name(), column_name()}],
  strategy :: :backward | :forward | :nearest
) :: df()
```

# `lazy`

```elixir
@callback lazy() :: module()
```

# `lazy`

```elixir
@callback lazy(df()) :: df()
```

# `load_csv`

```elixir
@callback load_csv(
  contents :: String.t(),
  io_dtypes(),
  delimiter :: String.t(),
  nil_values :: [String.t()],
  skip_rows :: integer(),
  skip_rows_after_header :: integer(),
  header? :: boolean(),
  encoding :: String.t(),
  max_rows :: option(integer()),
  columns :: columns_for_io(),
  infer_schema_length :: option(integer()),
  parse_dates :: boolean(),
  eol_delimiter :: option(String.t()),
  quote_delimiter :: option(String.t())
) :: io_result(df())
```

# `load_ipc`

```elixir
@callback load_ipc(
  contents :: binary(),
  columns :: columns_for_io()
) :: io_result(df())
```

# `load_ipc_stream`

```elixir
@callback load_ipc_stream(
  contents :: binary(),
  columns :: columns_for_io()
) :: io_result(df())
```

# `load_ndjson`

```elixir
@callback load_ndjson(
  contents :: String.t(),
  infer_schema_length :: integer(),
  batch_size :: integer()
) :: io_result(df())
```

# `load_parquet`

```elixir
@callback load_parquet(contents :: binary()) :: io_result(df())
```

# `mask`

```elixir
@callback mask(df(), mask :: series()) :: df()
```

# `mutate_with`

```elixir
@callback mutate_with(df(), out_df :: df(), mutations :: [{column_name(), lazy_series()}]) ::
  df()
```

# `n_rows`

```elixir
@callback n_rows(df()) :: integer()
```

# `nil_count`

```elixir
@callback nil_count(df()) :: df()
```

# `pivot_longer`

```elixir
@callback pivot_longer(
  df(),
  out_df :: df(),
  columns_to_pivot :: [column_name()],
  columns_to_keep :: [column_name()],
  names_to :: column_name(),
  values_to :: column_name()
) :: df()
```

# `pivot_wider`

```elixir
@callback pivot_wider(
  df(),
  id_columns :: [column_name()],
  names_from :: column_name(),
  values_from :: [column_name()],
  names_prefix :: String.t()
) :: df()
```

# `pull`

```elixir
@callback pull(df(), column :: column_name()) :: series()
```

# `put`

```elixir
@callback put(df(), out_df :: df(), column_name(), series()) :: df()
```

# `re_dtype`

```elixir
@callback re_dtype(String.t()) :: dtype()
```

# `rename`

```elixir
@callback rename(df(), out_df :: df(), [{old :: column_name(), new :: column_name()}]) ::
  df()
```

# `sample`

```elixir
@callback sample(
  df(),
  n_or_frac :: number(),
  replace :: boolean(),
  shuffle :: boolean(),
  seed :: option(integer())
) :: df()
```

# `select`

```elixir
@callback select(df(), out_df :: df()) :: df()
```

# `slice`

```elixir
@callback slice(
  df(),
  indices ::
    [integer()] | series() | %Range{first: term(), last: term(), step: term()}
) ::
  df()
```

# `slice`

```elixir
@callback slice(df(), offset :: integer(), length :: integer()) :: df()
```

# `sort_with`

```elixir
@callback sort_with(
  df(),
  out_df :: df(),
  directions :: [{:asc | :desc, lazy_series()}],
  maintain_order? :: boolean(),
  multithreaded? :: boolean(),
  nulls_last? :: boolean()
) :: df()
```

# `sql`

```elixir
@callback sql(df(), sql_string :: binary(), table_name :: binary()) :: df()
```

# `summarise_with`

```elixir
@callback summarise_with(
  df(),
  out_df :: df(),
  aggregations :: [{column_name(), lazy_series()}]
) :: df()
```

# `tail`

```elixir
@callback tail(df(), rows :: integer()) :: df()
```

# `to_csv`

```elixir
@callback to_csv(
  df(),
  entry :: fs_entry(),
  header? :: boolean(),
  delimiter :: String.t(),
  quote_style :: quote_style(),
  streaming :: boolean()
) :: ok_result()
```

# `to_ipc`

```elixir
@callback to_ipc(df(), entry :: fs_entry(), compression(), streaming :: boolean()) ::
  ok_result()
```

# `to_ipc_stream`

```elixir
@callback to_ipc_stream(
  df(),
  entry :: fs_entry(),
  compression()
) :: ok_result()
```

# `to_ndjson`

```elixir
@callback to_ndjson(df(), entry :: fs_entry()) :: ok_result()
```

# `to_parquet`

```elixir
@callback to_parquet(
  df(),
  entry :: fs_entry(),
  compression(),
  streaming :: boolean()
) :: ok_result()
```

# `to_rows`

```elixir
@callback to_rows(df(), atom_keys? :: boolean()) :: [map()]
```

# `to_rows_stream`

```elixir
@callback to_rows_stream(df(), atom_keys? :: boolean(), chunk_size :: integer()) ::
  Enumerable.t()
```

# `transpose`

```elixir
@callback transpose(
  df(),
  out_df :: df(),
  keep_names_as :: column_name(),
  new_column_names :: [column_name()]
) :: df()
```

# `unnest`

```elixir
@callback unnest(df(), out_df :: df(), columns :: [column_name()]) :: df()
```

# `inspect`

Default inspect implementation for backends.

# `new`

Creates a new DataFrame for a given backend.

---

*Consult [api-reference.md](api-reference.md) for complete listing*