# `SparkEx.Functions`
[🔗](https://github.com/lukaszsamson/spark_ex/blob/v0.1.1/lib/spark_ex/functions.ex#L1)

Expression constructors for Spark DataFrame operations.

Provides core constructors (`col/1`, `lit/1`, `expr/1`) and a comprehensive
set of Spark SQL functions generated from a declarative registry.

These functions create `SparkEx.Column` structs that can be used in
DataFrame transforms like `select/2`, `filter/2`, `with_column/3`, etc.

## Examples

    import SparkEx.Functions

    df
    |> SparkEx.DataFrame.select([col("name"), col("age")])
    |> SparkEx.DataFrame.filter(col("age") |> SparkEx.Column.gt(lit(18)))

# `abs`

```elixir
@spec abs(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes the absolute value.

Spark SQL function: `abs`

# `acos`

```elixir
@spec acos(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes inverse cosine.

Spark SQL function: `acos`

# `acosh`

```elixir
@spec acosh(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes inverse hyperbolic cosine.

Spark SQL function: `acosh`

# `add_months`

```elixir
@spec add_months(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Adds months to date.

Spark SQL function: `add_months`

# `aes_decrypt`

```elixir
@spec aes_decrypt([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

AES decrypts binary data.

Spark SQL function: `aes_decrypt`

# `aes_encrypt`

```elixir
@spec aes_encrypt([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

AES encrypts binary data.

Spark SQL function: `aes_encrypt`

# `aggregate`

```elixir
@spec aggregate(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | term(),
  (SparkEx.Column.t(), SparkEx.Column.t() -> SparkEx.Column.t()),
  (SparkEx.Column.t() -> SparkEx.Column.t()) | nil
) :: SparkEx.Column.t()
```

Aggregates elements in an array column using an initial value and a merge function.

The merge function receives two lambda variables: accumulator and element.
An optional finish function can be applied to the final accumulator value.

## Examples

    aggregate(col("arr"), lit(0), fn acc, x -> Column.plus(acc, x) end)
    aggregate(col("arr"), lit(0), fn acc, x -> Column.plus(acc, x) end, fn acc -> Column.cast(acc, "string") end)

# `any_value`

```elixir
@spec any_value(SparkEx.Column.t() | String.t(), boolean()) :: SparkEx.Column.t()
```

Returns any value from the group. Optionally ignores null values.

# `approx_count_distinct`

```elixir
@spec approx_count_distinct(SparkEx.Column.t() | String.t(), float() | nil) ::
  SparkEx.Column.t()
```

Approximate count of distinct values.

Optionally accepts a relative standard deviation parameter.

## Examples

    approx_count_distinct(col("x"))
    approx_count_distinct(col("x"), 0.05)

# `approx_percentile`

```elixir
@spec approx_percentile(SparkEx.Column.t() | String.t(), term(), term()) ::
  SparkEx.Column.t()
```

Approximate percentile with accuracy parameter.

Spark SQL function: `approx_percentile`

# `array`

```elixir
@spec array([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Creates array from columns.

Spark SQL function: `array`

# `array_agg`

```elixir
@spec array_agg(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `collect_list/1`.

# `array_append`

```elixir
@spec array_append(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Appends element to array.

Spark SQL function: `array_append`

# `array_compact`

```elixir
@spec array_compact(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Removes null values from array.

Spark SQL function: `array_compact`

# `array_contains`

```elixir
@spec array_contains(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Checks if array contains value.

Spark SQL function: `array_contains`

# `array_distinct`

```elixir
@spec array_distinct(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Removes duplicates from array.

Spark SQL function: `array_distinct`

# `array_except`

```elixir
@spec array_except(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns elements in first but not second array.

Spark SQL function: `array_except`

# `array_insert`

```elixir
@spec array_insert(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Inserts element at position in array.

Spark SQL function: `array_insert`

# `array_intersect`

```elixir
@spec array_intersect(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) ::
  SparkEx.Column.t()
```

Returns intersection of two arrays.

Spark SQL function: `array_intersect`

# `array_join`

```elixir
@spec array_join(SparkEx.Column.t() | String.t(), String.t(), String.t() | nil) ::
  SparkEx.Column.t()
```

Joins array elements with delimiter.

Optionally accepts a null_replacement string.

## Examples

    array_join(col("arr"), ",")
    array_join(col("arr"), ",", "NULL")

# `array_max`

```elixir
@spec array_max(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns max element of array.

Spark SQL function: `array_max`

# `array_min`

```elixir
@spec array_min(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns min element of array.

Spark SQL function: `array_min`

# `array_position`

```elixir
@spec array_position(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Locates element in array (1-based).

Spark SQL function: `array_position`

# `array_prepend`

```elixir
@spec array_prepend(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Prepends element to array.

Spark SQL function: `array_prepend`

# `array_remove`

```elixir
@spec array_remove(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Removes all occurrences of element from array.

Spark SQL function: `array_remove`

# `array_repeat`

```elixir
@spec array_repeat(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Creates array with element repeated n times.

Spark SQL function: `array_repeat`

# `array_size`

```elixir
@spec array_size(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns array size.

Spark SQL function: `array_size`

# `array_sort`

```elixir
@spec array_sort(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Sorts array in ascending order. Optional comparator function.

# `array_sort`

```elixir
@spec array_sort(SparkEx.Column.t() | String.t(), (SparkEx.Column.t(),
                                             SparkEx.Column.t() ->
                                               SparkEx.Column.t())) ::
  SparkEx.Column.t()
```

# `array_union`

```elixir
@spec array_union(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns union of two arrays.

Spark SQL function: `array_union`

# `arrays_overlap`

```elixir
@spec arrays_overlap(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns true if arrays have common elements.

Spark SQL function: `arrays_overlap`

# `arrays_zip`

```elixir
@spec arrays_zip([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Zips arrays into array of structs.

Spark SQL function: `arrays_zip`

# `asc`

```elixir
@spec asc(SparkEx.Column.t()) :: SparkEx.Column.t()
```

Sort ascending by the given column

# `asc_nulls_first`

```elixir
@spec asc_nulls_first(SparkEx.Column.t()) :: SparkEx.Column.t()
```

Sort ascending with nulls first

# `asc_nulls_last`

```elixir
@spec asc_nulls_last(SparkEx.Column.t()) :: SparkEx.Column.t()
```

Sort ascending with nulls last

# `ascii`

```elixir
@spec ascii(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

ASCII value of first character.

Spark SQL function: `ascii`

# `asin`

```elixir
@spec asin(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes inverse sine.

Spark SQL function: `asin`

# `asinh`

```elixir
@spec asinh(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes inverse hyperbolic sine.

Spark SQL function: `asinh`

# `assert_true`

```elixir
@spec assert_true(
  SparkEx.Column.t() | String.t(),
  String.t() | SparkEx.Column.t() | nil
) ::
  SparkEx.Column.t()
```

Raises error if condition is false.

Optionally accepts an error message.

## Examples

    assert_true(col("cond"))
    assert_true(col("cond"), "Assertion failed!")

# `atan2`

```elixir
@spec atan2(
  SparkEx.Column.t() | String.t() | number(),
  SparkEx.Column.t() | String.t() | number()
) ::
  SparkEx.Column.t()
```

Computes atan2(y, x). Both arguments can be columns or numeric values.

# `atan`

```elixir
@spec atan(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes inverse tangent.

Spark SQL function: `atan`

# `atanh`

```elixir
@spec atanh(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes inverse hyperbolic tangent.

Spark SQL function: `atanh`

# `avg`

```elixir
@spec avg(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes average.

Spark SQL function: `avg`

# `base64`

```elixir
@spec base64(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Base64 encodes binary.

Spark SQL function: `base64`

# `bin`

```elixir
@spec bin(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Binary string representation of integer.

Spark SQL function: `bin`

# `bit_and`

```elixir
@spec bit_and(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Bitwise AND aggregate.

Spark SQL function: `bit_and`

# `bit_count`

```elixir
@spec bit_count(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Counts number of set bits.

Spark SQL function: `bit_count`

# `bit_get`

```elixir
@spec bit_get(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Returns the value of the bit at the given position.

Spark SQL function: `bit_get`

# `bit_length`

```elixir
@spec bit_length(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns bit length of string.

Spark SQL function: `bit_length`

# `bit_or`

```elixir
@spec bit_or(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Bitwise OR aggregate.

Spark SQL function: `bit_or`

# `bit_xor`

```elixir
@spec bit_xor(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Bitwise XOR aggregate.

Spark SQL function: `bit_xor`

# `bitmap_and_agg`

```elixir
@spec bitmap_and_agg(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Aggregate AND of bitmaps.

Spark SQL function: `bitmap_and_agg`

# `bitmap_bit_position`

```elixir
@spec bitmap_bit_position(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns bit position within a bitmap bucket.

Spark SQL function: `bitmap_bit_position`

# `bitmap_bucket_number`

```elixir
@spec bitmap_bucket_number(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns bitmap bucket number.

Spark SQL function: `bitmap_bucket_number`

# `bitmap_construct_agg`

```elixir
@spec bitmap_construct_agg(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Constructs a bitmap from bit positions.

Spark SQL function: `bitmap_construct_agg`

# `bitmap_count`

```elixir
@spec bitmap_count(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Counts set bits in a bitmap.

Spark SQL function: `bitmap_count`

# `bitmap_or_agg`

```elixir
@spec bitmap_or_agg(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Aggregate OR of bitmaps.

Spark SQL function: `bitmap_or_agg`

# `bitwise_not_`

```elixir
@spec bitwise_not_(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Bitwise NOT (standalone function).

Spark SQL function: `~`

# `bool_and`

```elixir
@spec bool_and(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

True if all values are true.

Spark SQL function: `bool_and`

# `bool_or`

```elixir
@spec bool_or(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

True if any value is true.

Spark SQL function: `bool_or`

# `broadcast`

```elixir
@spec broadcast(SparkEx.DataFrame.t()) :: SparkEx.DataFrame.t()
```

Returns a DataFrame with a broadcast hint for join optimization.

## Examples

    broadcast(df)

# `bround`

```elixir
@spec bround(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Banker's rounding to `scale` decimal places.

Spark SQL function: `bround`

# `btrim`

```elixir
@spec btrim(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Trims characters from both sides.

Spark SQL function: `btrim`

# `bucket`

```elixir
@spec bucket(SparkEx.Column.t() | integer(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns the bucket number for a value and number of buckets.

# `call_function`

```elixir
@spec call_function(String.t(), list(), list()) :: SparkEx.Column.t()
```

Calls a function with positional and named arguments.

# `call_udf`

```elixir
@spec call_udf(String.t(), [SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Calls a registered UDF by name with the given column arguments.

Equivalent to PySpark's `call_udf`.

# `cardinality`

```elixir
@spec cardinality(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `size/1`.

# `cbrt`

```elixir
@spec cbrt(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes cube root.

Spark SQL function: `cbrt`

# `ceil`

```elixir
@spec ceil(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes ceiling.

Spark SQL function: `ceil`

# `ceiling`

```elixir
@spec ceiling(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `ceil/1`.

# `char_`

```elixir
@spec char_(term()) :: SparkEx.Column.t()
```

Returns character from ASCII code.

Spark SQL function: `char`

# `char_length`

```elixir
@spec char_length(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Character length of string.

Spark SQL function: `char_length`

# `character_length`

```elixir
@spec character_length(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `char_length/1`.

# `chr`

```elixir
@spec chr(term()) :: SparkEx.Column.t()
```

Alias for `char_/1`.

# `coalesce`

```elixir
@spec coalesce([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Returns first non-null value.

Spark SQL function: `coalesce`

# `col`

```elixir
@spec col(String.t()) :: SparkEx.Column.t()
```

Creates a column reference by name.

## Examples

    col("age")
    col("users.name")

# `collate`

```elixir
@spec collate(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Applies collation to string.

Spark SQL function: `collate`

# `collation`

```elixir
@spec collation(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns collation of string column.

Spark SQL function: `collation`

# `collect_list`

```elixir
@spec collect_list(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Collects values into list.

Spark SQL function: `collect_list`

# `collect_set`

```elixir
@spec collect_set(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Collects distinct values into set.

Spark SQL function: `collect_set`

# `concat`

```elixir
@spec concat([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Concatenates columns.

Spark SQL function: `concat`

# `concat_ws`

```elixir
@spec concat_ws(
  term(),
  SparkEx.Column.t() | String.t() | [SparkEx.Column.t() | String.t()]
) ::
  SparkEx.Column.t()
```

Concatenates with separator.

Spark SQL function: `concat_ws`

# `contains_`

```elixir
@spec contains_(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns true if string contains substring.

Spark SQL function: `contains`

# `conv`

```elixir
@spec conv(SparkEx.Column.t() | String.t(), term(), term()) :: SparkEx.Column.t()
```

Converts number between bases.

Spark SQL function: `conv`

# `convert_timezone`

```elixir
@spec convert_timezone(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) ::
  SparkEx.Column.t()
```

Converts timestamp between timezones. 2-arg form uses session timezone as source.

# `convert_timezone`

```elixir
@spec convert_timezone(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

# `corr`

```elixir
@spec corr(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Pearson correlation.

Spark SQL function: `corr`

# `cos`

```elixir
@spec cos(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes cosine.

Spark SQL function: `cos`

# `cosh`

```elixir
@spec cosh(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes hyperbolic cosine.

Spark SQL function: `cosh`

# `cot`

```elixir
@spec cot(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes cotangent.

Spark SQL function: `cot`

# `count`

```elixir
@spec count(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Counts non-null values.

Spark SQL function: `count`

# `count_distinct`

```elixir
@spec count_distinct(
  SparkEx.Column.t()
  | String.t()
  | [SparkEx.Column.t() | String.t()]
) ::
  SparkEx.Column.t()
```

Counts distinct non-null values.

Accepts a single column or a list of columns for multi-column distinct count.

## Examples

    count_distinct(col("x"))
    count_distinct(["x", "y", "z"])

# `count_if`

```elixir
@spec count_if(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Counts rows where condition is true.

Spark SQL function: `count_if`

# `count_min_sketch`

```elixir
@spec count_min_sketch(SparkEx.Column.t() | String.t(), term(), term(), term()) ::
  SparkEx.Column.t()
```

Creates a count-min sketch of a column with given eps, confidence, and seed.

Spark SQL function: `count_min_sketch`

# `covar_pop`

```elixir
@spec covar_pop(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Population covariance.

Spark SQL function: `covar_pop`

# `covar_samp`

```elixir
@spec covar_samp(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Sample covariance.

Spark SQL function: `covar_samp`

# `crc32`

```elixir
@spec crc32(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

CRC32 hash.

Spark SQL function: `crc32`

# `create_map`

```elixir
@spec create_map([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Creates map from key-value column pairs.

Spark SQL function: `map`

# `csc`

```elixir
@spec csc(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes cosecant.

Spark SQL function: `csc`

# `cume_dist`

```elixir
@spec cume_dist() :: SparkEx.Column.t()
```

Cumulative distribution within partition.

Spark SQL function: `cume_dist`

# `curdate`

```elixir
@spec curdate() :: SparkEx.Column.t()
```

Alias for `current_date/0`.

# `current_catalog`

```elixir
@spec current_catalog() :: SparkEx.Column.t()
```

Returns current catalog name.

Spark SQL function: `current_catalog`

# `current_database`

```elixir
@spec current_database() :: SparkEx.Column.t()
```

Returns current database name.

Spark SQL function: `current_database`

# `current_date`

```elixir
@spec current_date() :: SparkEx.Column.t()
```

Returns current date.

Spark SQL function: `current_date`

# `current_schema`

```elixir
@spec current_schema() :: SparkEx.Column.t()
```

Alias for `current_database/0`.

# `current_time`

```elixir
@spec current_time() :: SparkEx.Column.t()
```

Returns current time.

Spark SQL function: `current_time`

# `current_timestamp`

```elixir
@spec current_timestamp() :: SparkEx.Column.t()
```

Returns current timestamp.

Spark SQL function: `current_timestamp`

# `current_timezone`

```elixir
@spec current_timezone() :: SparkEx.Column.t()
```

Returns current timezone string.

Spark SQL function: `current_timezone`

# `current_user_`

```elixir
@spec current_user_() :: SparkEx.Column.t()
```

Returns current user name.

Spark SQL function: `current_user`

# `date_add`

```elixir
@spec date_add(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Adds days to date.

Spark SQL function: `date_add`

# `date_diff`

```elixir
@spec date_diff(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Alias for `datediff/2`.

# `date_format`

```elixir
@spec date_format(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Formats date/timestamp with pattern.

Spark SQL function: `date_format`

# `date_from_unix_date`

```elixir
@spec date_from_unix_date(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates date from days since epoch.

Spark SQL function: `date_from_unix_date`

# `date_part`

```elixir
@spec date_part(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Alias for `extract/2`.

# `date_sub`

```elixir
@spec date_sub(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Subtracts days from date.

Spark SQL function: `date_sub`

# `date_trunc`

```elixir
@spec date_trunc(
  term(),
  SparkEx.Column.t() | String.t() | [SparkEx.Column.t() | String.t()]
) ::
  SparkEx.Column.t()
```

Truncates date to specified unit.

Spark SQL function: `date_trunc`

# `dateadd`

```elixir
@spec dateadd(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Alias for `date_add/2`.

# `datediff`

```elixir
@spec datediff(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Difference in days between dates.

Spark SQL function: `datediff`

# `datepart`

```elixir
@spec datepart(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Alias for `extract/2`.

# `day`

```elixir
@spec day(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts day.

Spark SQL function: `day`

# `dayname`

```elixir
@spec dayname(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns day name.

Spark SQL function: `dayname`

# `dayofmonth`

```elixir
@spec dayofmonth(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `day/1`.

# `dayofweek`

```elixir
@spec dayofweek(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Day of week (1=Sun).

Spark SQL function: `dayofweek`

# `dayofyear`

```elixir
@spec dayofyear(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Day of year.

Spark SQL function: `dayofyear`

# `days`

```elixir
@spec days(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts days from an interval expression.

# `decode`

```elixir
@spec decode(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Decodes binary with charset.

Spark SQL function: `decode`

# `degrees`

```elixir
@spec degrees(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Converts radians to degrees.

Spark SQL function: `degrees`

# `dense_rank`

```elixir
@spec dense_rank() :: SparkEx.Column.t()
```

Dense rank within partition.

Spark SQL function: `dense_rank`

# `desc`

```elixir
@spec desc(SparkEx.Column.t()) :: SparkEx.Column.t()
```

Sort descending by the given column

# `desc_nulls_first`

```elixir
@spec desc_nulls_first(SparkEx.Column.t()) :: SparkEx.Column.t()
```

Sort descending with nulls first

# `desc_nulls_last`

```elixir
@spec desc_nulls_last(SparkEx.Column.t()) :: SparkEx.Column.t()
```

Sort descending with nulls last

# `e`

```elixir
@spec e() :: SparkEx.Column.t()
```

Returns Euler's number.

Spark SQL function: `e`

# `element_at`

```elixir
@spec element_at(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns element at index/key.

Spark SQL function: `element_at`

# `elt`

```elixir
@spec elt([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Returns the n-th input string.

Spark SQL function: `elt`

# `encode`

```elixir
@spec encode(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Encodes string with charset.

Spark SQL function: `encode`

# `endswith`

```elixir
@spec endswith(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns true if string ends with suffix.

Spark SQL function: `endsWith`

# `equal_null`

```elixir
@spec equal_null(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Null-safe equality.

Spark SQL function: `equal_null`

# `every`

```elixir
@spec every(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `bool_and/1`.

# `exists`

```elixir
@spec exists(SparkEx.Column.t() | String.t(), (SparkEx.Column.t() ->
                                           SparkEx.Column.t())) ::
  SparkEx.Column.t()
```

Returns true if any element in the array satisfies the predicate.

## Examples

    exists(col("arr"), fn x -> Column.gt(x, lit(0)) end)

# `exp`

```elixir
@spec exp(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes exponential.

Spark SQL function: `exp`

# `explode`

```elixir
@spec explode(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates a row for each array/map element.

Spark SQL function: `explode`

# `explode_outer`

```elixir
@spec explode_outer(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Like explode but preserves nulls.

Spark SQL function: `explode_outer`

# `expm1`

```elixir
@spec expm1(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes exp(x) - 1.

Spark SQL function: `expm1`

# `expr`

```elixir
@spec expr(String.t()) :: SparkEx.Column.t()
```

Creates an expression from a SQL expression string.

This is a convenient escape hatch for expressions that are easier
to write in SQL syntax.

## Examples

    expr("age + 1")
    expr("CASE WHEN age > 18 THEN 'adult' ELSE 'minor' END")

# `extract`

```elixir
@spec extract(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Extracts date/time field.

Spark SQL function: `extract`

# `factorial`

```elixir
@spec factorial(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes factorial.

Spark SQL function: `factorial`

# `filter`

```elixir
@spec filter(
  SparkEx.Column.t() | String.t(),
  (SparkEx.Column.t() -> SparkEx.Column.t())
  | (SparkEx.Column.t(), SparkEx.Column.t() -> SparkEx.Column.t())
) :: SparkEx.Column.t()
```

Filters an array column using a predicate function.

## Examples

    filter(col("arr"), fn x -> Column.gt(x, lit(0)) end)

# `find_in_set`

```elixir
@spec find_in_set(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns position of string in comma-delimited list.

Spark SQL function: `find_in_set`

# `first`

```elixir
@spec first(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Returns first value.

Spark SQL function: `first`

# `first_value`

```elixir
@spec first_value(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Alias for `first/2`.

# `flatten`

```elixir
@spec flatten(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Flattens nested array.

Spark SQL function: `flatten`

# `floor`

```elixir
@spec floor(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes floor.

Spark SQL function: `floor`

# `forall`

```elixir
@spec forall(SparkEx.Column.t() | String.t(), (SparkEx.Column.t() ->
                                           SparkEx.Column.t())) ::
  SparkEx.Column.t()
```

Returns true if all elements in the array satisfy the predicate.

## Examples

    forall(col("arr"), fn x -> Column.gt(x, lit(0)) end)

# `format_number`

```elixir
@spec format_number(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Formats number with d decimal places.

Spark SQL function: `format_number`

# `format_string`

```elixir
@spec format_string(
  term(),
  SparkEx.Column.t() | String.t() | [SparkEx.Column.t() | String.t()]
) ::
  SparkEx.Column.t()
```

printf-style formatting.

Spark SQL function: `format_string`

# `from_avro`

```elixir
@spec from_avro(SparkEx.Column.t() | String.t(), String.t(), map() | nil) ::
  SparkEx.Column.t()
```

Decodes Avro binary using the provided JSON schema.

# `from_csv`

```elixir
@spec from_csv(SparkEx.Column.t() | String.t(), String.t(), map() | nil) ::
  SparkEx.Column.t()
```

Parses a CSV string column into a struct column using the given schema.

## Examples

    from_csv(col("csv_str"), "a INT, b STRING")
    from_csv(col("csv_str"), "a INT, b STRING", %{"sep" => "|"})

# `from_json`

```elixir
@spec from_json(
  SparkEx.Column.t() | String.t(),
  String.t() | SparkEx.Types.data_type_proto(),
  map() | nil
) :: SparkEx.Column.t()
```

Parses a JSON string column into a struct/array/map column using the given schema.

The schema can be a DDL string or a Spark DataType protobuf struct.

## Examples

    from_json(col("json_str"), "a INT, b STRING")
    from_json(col("json_str"), "a INT", %{"mode" => "FAILFAST"})

# `from_protobuf`

```elixir
@spec from_protobuf(SparkEx.Column.t() | String.t(), String.t(), keyword()) ::
  SparkEx.Column.t()
```

Decodes Protobuf binary using the provided message name and descriptor.

Either `desc_file_path` or `binary_descriptor_set` can be provided (only one).

# `from_unixtime`

```elixir
@spec from_unixtime(SparkEx.Column.t() | String.t(), String.t()) :: SparkEx.Column.t()
```

Converts unix timestamp to string. Always sends format (default "yyyy-MM-dd HH:mm:ss").

# `from_utc_timestamp`

```elixir
@spec from_utc_timestamp(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Converts UTC timestamp to timezone.

Spark SQL function: `from_utc_timestamp`

# `from_xml`

```elixir
@spec from_xml(SparkEx.Column.t() | String.t(), String.t(), map() | nil) ::
  SparkEx.Column.t()
```

Parses an XML string column into a struct column using the given schema.

## Examples

    from_xml(col("xml_str"), "a INT, b STRING")
    from_xml(col("xml_str"), "a INT, b STRING", %{"rowTag" => "item"})

# `get`

```elixir
@spec get(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Returns element at index from array.

Spark SQL function: `get`

# `get_json_object`

```elixir
@spec get_json_object(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Extracts JSON object from path expression.

Spark SQL function: `get_json_object`

# `getbit`

```elixir
@spec getbit(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Alias for `bit_get/2`.

# `greatest`

```elixir
@spec greatest([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Returns greatest value.

Spark SQL function: `greatest`

# `grouping`

```elixir
@spec grouping(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Indicates whether column is aggregated in grouping set.

Spark SQL function: `grouping`

# `grouping_id`

```elixir
@spec grouping_id([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Grouping ID for grouping set.

Spark SQL function: `grouping_id`

# `hash`

```elixir
@spec hash([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Murmur3 hash of columns.

Spark SQL function: `hash`

# `hex`

```elixir
@spec hex(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Hex string of integer/binary.

Spark SQL function: `hex`

# `histogram_numeric`

```elixir
@spec histogram_numeric(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Computes histogram of column.

Spark SQL function: `histogram_numeric`

# `hll_sketch_agg`

```elixir
@spec hll_sketch_agg(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregates values into an HLL sketch.

Spark SQL function: `hll_sketch_agg`

# `hll_sketch_estimate`

```elixir
@spec hll_sketch_estimate(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Estimates distinct count from an HLL sketch.

Spark SQL function: `hll_sketch_estimate`

# `hll_union`

```elixir
@spec hll_union(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Unions two HLL sketches.

Spark SQL function: `hll_union`

# `hll_union_agg`

```elixir
@spec hll_union_agg(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregate union of HLL sketches.

Spark SQL function: `hll_union_agg`

# `hour`

```elixir
@spec hour(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts hour.

Spark SQL function: `hour`

# `hours`

```elixir
@spec hours(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts hours from an interval expression.

# `hypot`

```elixir
@spec hypot(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Computes sqrt(a^2 + b^2).

Spark SQL function: `hypot`

# `ifnull`

```elixir
@spec ifnull(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns second value if first is null.

Spark SQL function: `ifnull`

# `ilike_`

```elixir
@spec ilike_(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t() | nil
) :: SparkEx.Column.t()
```

Case-insensitive LIKE. Optional escape character.

# `initcap`

```elixir
@spec initcap(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Title-cases string.

Spark SQL function: `initcap`

# `inline`

```elixir
@spec inline(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Explodes array of structs into columns.

Spark SQL function: `inline`

# `inline_outer`

```elixir
@spec inline_outer(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Like inline but preserves nulls.

Spark SQL function: `inline_outer`

# `input_file_block_length`

```elixir
@spec input_file_block_length() :: SparkEx.Column.t()
```

Length of current file block.

Spark SQL function: `input_file_block_length`

# `input_file_block_start`

```elixir
@spec input_file_block_start() :: SparkEx.Column.t()
```

Start offset of current file block.

Spark SQL function: `input_file_block_start`

# `input_file_name`

```elixir
@spec input_file_name() :: SparkEx.Column.t()
```

Name of file being read.

Spark SQL function: `input_file_name`

# `instr`

```elixir
@spec instr(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Position of first occurrence of substr.

Spark SQL function: `instr`

# `is_valid_utf8`

```elixir
@spec is_valid_utf8(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns true if string is valid UTF-8.

Spark SQL function: `is_valid_utf8`

# `is_variant_null`

```elixir
@spec is_variant_null(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for variant null checks.

# `isnan`

```elixir
@spec isnan(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

True if NaN.

Spark SQL function: `isNaN`

# `isnotnull`

```elixir
@spec isnotnull(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

True if not null.

Spark SQL function: `isNotNull`

# `isnull`

```elixir
@spec isnull(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

True if null.

Spark SQL function: `isNull`

# `java_method`

```elixir
@spec java_method([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Calls a JVM method.

Spark SQL function: `java_method`

# `json_array_length`

```elixir
@spec json_array_length(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns length of outermost JSON array.

Spark SQL function: `json_array_length`

# `json_object_keys`

```elixir
@spec json_object_keys(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns keys of outermost JSON object.

Spark SQL function: `json_object_keys`

# `json_tuple`

```elixir
@spec json_tuple(SparkEx.Column.t() | String.t(), [String.t()]) :: SparkEx.Column.t()
```

Extracts fields from a JSON string column.

First argument is the JSON column, remaining arguments are field name strings.

## Examples

    json_tuple(col("json_str"), ["name", "age"])

# `kll_sketch_agg_bigint`

```elixir
@spec kll_sketch_agg_bigint(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregates bigint values into a KLL sketch.

Spark SQL function: `kll_sketch_agg_bigint`

# `kll_sketch_agg_double`

```elixir
@spec kll_sketch_agg_double(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregates double values into a KLL sketch.

Spark SQL function: `kll_sketch_agg_double`

# `kll_sketch_agg_float`

```elixir
@spec kll_sketch_agg_float(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregates float values into a KLL sketch.

Spark SQL function: `kll_sketch_agg_float`

# `kll_sketch_get_n_bigint`

```elixir
@spec kll_sketch_get_n_bigint(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns n (number of items) from a KLL sketch (bigint).

Spark SQL function: `kll_sketch_get_n_bigint`

# `kll_sketch_get_n_double`

```elixir
@spec kll_sketch_get_n_double(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns n (number of items) from a KLL sketch (double).

Spark SQL function: `kll_sketch_get_n_double`

# `kll_sketch_get_n_float`

```elixir
@spec kll_sketch_get_n_float(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns n (number of items) from a KLL sketch (float).

Spark SQL function: `kll_sketch_get_n_float`

# `kll_sketch_get_quantile_bigint`

```elixir
@spec kll_sketch_get_quantile_bigint(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Gets quantile from a KLL sketch (bigint).

Spark SQL function: `kll_sketch_get_quantile_bigint`

# `kll_sketch_get_quantile_double`

```elixir
@spec kll_sketch_get_quantile_double(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Gets quantile from a KLL sketch (double).

Spark SQL function: `kll_sketch_get_quantile_double`

# `kll_sketch_get_quantile_float`

```elixir
@spec kll_sketch_get_quantile_float(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Gets quantile from a KLL sketch (float).

Spark SQL function: `kll_sketch_get_quantile_float`

# `kll_sketch_get_rank_bigint`

```elixir
@spec kll_sketch_get_rank_bigint(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Gets rank from a KLL sketch (bigint).

Spark SQL function: `kll_sketch_get_rank_bigint`

# `kll_sketch_get_rank_double`

```elixir
@spec kll_sketch_get_rank_double(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Gets rank from a KLL sketch (double).

Spark SQL function: `kll_sketch_get_rank_double`

# `kll_sketch_get_rank_float`

```elixir
@spec kll_sketch_get_rank_float(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Gets rank from a KLL sketch (float).

Spark SQL function: `kll_sketch_get_rank_float`

# `kll_sketch_merge_bigint`

```elixir
@spec kll_sketch_merge_bigint(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) ::
  SparkEx.Column.t()
```

Merges KLL sketches (bigint).

Spark SQL function: `kll_sketch_merge_bigint`

# `kll_sketch_merge_double`

```elixir
@spec kll_sketch_merge_double(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) ::
  SparkEx.Column.t()
```

Merges KLL sketches (double).

Spark SQL function: `kll_sketch_merge_double`

# `kll_sketch_merge_float`

```elixir
@spec kll_sketch_merge_float(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) ::
  SparkEx.Column.t()
```

Merges KLL sketches (float).

Spark SQL function: `kll_sketch_merge_float`

# `kll_sketch_to_string_bigint`

```elixir
@spec kll_sketch_to_string_bigint(SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Converts a KLL sketch (bigint) to a string.

Spark SQL function: `kll_sketch_to_string_bigint`

# `kll_sketch_to_string_double`

```elixir
@spec kll_sketch_to_string_double(SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Converts a KLL sketch (double) to a string.

Spark SQL function: `kll_sketch_to_string_double`

# `kll_sketch_to_string_float`

```elixir
@spec kll_sketch_to_string_float(SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Converts a KLL sketch (float) to a string.

Spark SQL function: `kll_sketch_to_string_float`

# `kurtosis`

```elixir
@spec kurtosis(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Kurtosis.

Spark SQL function: `kurtosis`

# `lag`

```elixir
@spec lag(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Value at offset rows before current.

Spark SQL function: `lag`

# `last`

```elixir
@spec last(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Returns last value.

Spark SQL function: `last`

# `last_day`

```elixir
@spec last_day(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Last day of month for date.

Spark SQL function: `last_day`

# `last_value`

```elixir
@spec last_value(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Alias for `last/2`.

# `lcase`

```elixir
@spec lcase(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `lower/1`.

# `lead`

```elixir
@spec lead(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Value at offset rows after current.

Spark SQL function: `lead`

# `least`

```elixir
@spec least([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Returns least value.

Spark SQL function: `least`

# `left_`

```elixir
@spec left_(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns leftmost n characters.

Spark SQL function: `left`

# `length`

```elixir
@spec length(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns length of string or binary.

Spark SQL function: `length`

# `levenshtein`

```elixir
@spec levenshtein(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  integer() | nil
) ::
  SparkEx.Column.t()
```

Levenshtein edit distance between strings.

Optionally accepts a threshold parameter.

## Examples

    levenshtein(col("s1"), col("s2"))
    levenshtein(col("s1"), col("s2"), 5)

# `like_`

```elixir
@spec like_(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t() | nil
) :: SparkEx.Column.t()
```

SQL LIKE pattern match. Optional escape character.

# `listagg`

```elixir
@spec listagg(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Concatenates values as string.

Spark SQL function: `listagg`

# `listagg_distinct`

```elixir
@spec listagg_distinct(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Concatenates distinct values as string.

Spark SQL function: `listagg`

# `lit`

```elixir
@spec lit(term()) :: SparkEx.Column.t()
```

Creates a literal value expression.

If a `Column` is passed, it is returned as-is (pass-through).
Supports nil, booleans, integers, floats, and strings.

## Examples

    lit(42)
    lit("hello")
    lit(true)
    lit(col("age"))  # returns the Column unchanged

# `ln`

```elixir
@spec ln(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `log/1`.

# `localtimestamp_`

```elixir
@spec localtimestamp_() :: SparkEx.Column.t()
```

Returns current local timestamp.

Spark SQL function: `localtimestamp`

# `locate`

```elixir
@spec locate(String.t(), SparkEx.Column.t() | String.t(), integer()) ::
  SparkEx.Column.t()
```

Locates position of substring in a string column. Optional `pos` start position (default 1).

# `log1p`

```elixir
@spec log1p(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes ln(1 + x).

Spark SQL function: `log1p`

# `log2`

```elixir
@spec log2(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes base-2 logarithm.

Spark SQL function: `log2`

# `log10`

```elixir
@spec log10(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes base-10 logarithm.

Spark SQL function: `log10`

# `log`

```elixir
@spec log(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes natural logarithm.

Spark SQL function: `ln`

# `log`

```elixir
@spec log(number(), SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes logarithm with the specified base.

`log(col)` is defined in the registry as natural log (`ln`).
`log(base, col)` computes `log_base(col)`.

## Examples

    log(2, col("x"))
    log(10, col("x"))

# `lower`

```elixir
@spec lower(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Converts to lowercase.

Spark SQL function: `lower`

# `lpad`

```elixir
@spec lpad(SparkEx.Column.t() | String.t(), term(), term()) :: SparkEx.Column.t()
```

Left-pads string to length with pad string.

Spark SQL function: `lpad`

# `ltrim`

```elixir
@spec ltrim(SparkEx.Column.t() | String.t(), String.t() | nil) :: SparkEx.Column.t()
```

Left-trims whitespace or specified characters.

# `make_date`

```elixir
@spec make_date(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Creates date from year, month, day.

Spark SQL function: `make_date`

# `make_dt_interval`

```elixir
@spec make_dt_interval(keyword()) :: SparkEx.Column.t()
```

Creates a day-time interval from optional components.

## Options

  * `:days` — days column (default: `lit(0)`)
  * `:hours` — hours column (default: `lit(0)`)
  * `:mins` — minutes column (default: `lit(0)`)
  * `:secs` — seconds column (default: `lit(0)`)

# `make_interval`

```elixir
@spec make_interval(keyword()) :: SparkEx.Column.t()
```

Creates an interval from optional components.

## Options

  * `:years`, `:months`, `:weeks`, `:days`, `:hours`, `:mins`, `:secs`
  All default to `lit(0)`.

# `make_time`

```elixir
@spec make_time(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Creates time from hour, minute, second.

Spark SQL function: `make_time`

# `make_timestamp`

```elixir
@spec make_timestamp([SparkEx.Column.t() | String.t()] | keyword()) ::
  SparkEx.Column.t()
```

Creates a timestamp from individual components or from date+time columns.

## Examples

    make_timestamp(col("y"), col("m"), col("d"), col("h"), col("min"), col("sec"))
    make_timestamp(col("y"), col("m"), col("d"), col("h"), col("min"), col("sec"), col("tz"))
    make_timestamp(date: col("d"), time: col("t"))
    make_timestamp(date: col("d"), time: col("t"), timezone: col("tz"))

# `make_timestamp_ltz`

```elixir
@spec make_timestamp_ltz([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Creates a timestamp with local timezone from components.

## Examples

    make_timestamp_ltz([col("y"), col("m"), col("d"), col("h"), col("min"), col("sec")])

# `make_timestamp_ntz`

```elixir
@spec make_timestamp_ntz([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Creates a timestamp without timezone from components.

## Examples

    make_timestamp_ntz([col("y"), col("m"), col("d"), col("h"), col("min"), col("sec")])

# `make_valid_utf8`

```elixir
@spec make_valid_utf8(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Replaces invalid UTF-8 with replacement char.

Spark SQL function: `make_valid_utf8`

# `make_ym_interval`

```elixir
@spec make_ym_interval(keyword()) :: SparkEx.Column.t()
```

Creates a year-month interval from optional components.

## Options

  * `:years` — years column (default: `lit(0)`)
  * `:months` — months column (default: `lit(0)`)

# `map_concat`

```elixir
@spec map_concat([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Concatenates maps.

Spark SQL function: `map_concat`

# `map_contains_key`

```elixir
@spec map_contains_key(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) ::
  SparkEx.Column.t()
```

Returns true if map contains the given key.

Spark SQL function: `map_contains_key`

# `map_entries`

```elixir
@spec map_entries(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns map entries as array of structs.

Spark SQL function: `map_entries`

# `map_filter`

```elixir
@spec map_filter(SparkEx.Column.t() | String.t(), (SparkEx.Column.t(),
                                             SparkEx.Column.t() ->
                                               SparkEx.Column.t())) ::
  SparkEx.Column.t()
```

Filters entries in a map column using a predicate on key and value.

## Examples

    map_filter(col("m"), fn k, v -> Column.gt(v, lit(0)) end)

# `map_from_arrays`

```elixir
@spec map_from_arrays(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) ::
  SparkEx.Column.t()
```

Creates map from key and value arrays.

Spark SQL function: `map_from_arrays`

# `map_from_entries`

```elixir
@spec map_from_entries(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates map from array of entries.

Spark SQL function: `map_from_entries`

# `map_keys`

```elixir
@spec map_keys(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns map keys.

Spark SQL function: `map_keys`

# `map_values`

```elixir
@spec map_values(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns map values.

Spark SQL function: `map_values`

# `map_zip_with`

```elixir
@spec map_zip_with(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  (SparkEx.Column.t(), SparkEx.Column.t(), SparkEx.Column.t() ->
     SparkEx.Column.t())
) :: SparkEx.Column.t()
```

Merges two maps using a function on overlapping keys.

The function receives three lambda variables: key, value1, value2.

## Examples

    map_zip_with(col("m1"), col("m2"), fn k, v1, v2 -> Column.plus(v1, v2) end)

# `mask`

```elixir
@spec mask(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Masks string characters.

Spark SQL function: `mask`

# `max`

```elixir
@spec max(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes maximum.

Spark SQL function: `max`

# `max_by`

```elixir
@spec max_by(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Value of first col at max of second.

Spark SQL function: `max_by`

# `md5`

```elixir
@spec md5(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

MD5 hash.

Spark SQL function: `md5`

# `mean`

```elixir
@spec mean(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `avg/1`.

# `median`

```elixir
@spec median(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Median value.

Spark SQL function: `median`

# `min`

```elixir
@spec min(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes minimum.

Spark SQL function: `min`

# `min_by`

```elixir
@spec min_by(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Value of first col at min of second.

Spark SQL function: `min_by`

# `minute`

```elixir
@spec minute(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts minute.

Spark SQL function: `minute`

# `mode`

```elixir
@spec mode(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Most frequent value in group.

# `mode`

```elixir
@spec mode(SparkEx.Column.t() | String.t(), boolean()) :: SparkEx.Column.t()
```

Most frequent value in group. Optional deterministic parameter (Spark 4.x+).

# `monotonically_increasing_id`

```elixir
@spec monotonically_increasing_id() :: SparkEx.Column.t()
```

Globally unique monotonically increasing ID.

Spark SQL function: `monotonically_increasing_id`

# `month`

```elixir
@spec month(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts month.

Spark SQL function: `month`

# `monthname`

```elixir
@spec monthname(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns month name.

Spark SQL function: `monthname`

# `months`

```elixir
@spec months(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts months from an interval expression.

# `months_between`

```elixir
@spec months_between(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  boolean()
) ::
  SparkEx.Column.t()
```

Returns the number of months between two dates.

Always sends 3 arguments with `roundOff` defaulting to `true`.

## Examples

    months_between(col("d1"), col("d2"))
    months_between(col("d1"), col("d2"), false)

# `named_arg`

```elixir
@spec named_arg(String.t(), term()) :: SparkEx.Column.t()
```

Builds a named argument expression.

# `named_struct`

```elixir
@spec named_struct([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Creates struct with named fields.

Spark SQL function: `named_struct`

# `nanvl`

```elixir
@spec nanvl(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns second value if first is NaN.

Spark SQL function: `nanvl`

# `negative`

```elixir
@spec negative(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns negation.

Spark SQL function: `negative`

# `next_day`

```elixir
@spec next_day(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Next day of week after date.

Spark SQL function: `next_day`

# `now`

```elixir
@spec now() :: SparkEx.Column.t()
```

Alias for `current_timestamp/0`.

# `nth_value`

```elixir
@spec nth_value(
  SparkEx.Column.t() | String.t(),
  integer() | SparkEx.Column.t(),
  boolean()
) ::
  SparkEx.Column.t()
```

Returns the nth value in a window frame. Optionally ignores null values.

# `ntile`

```elixir
@spec ntile(term()) :: SparkEx.Column.t()
```

N-tile bucket number within partition.

Spark SQL function: `ntile`

# `nullif`

```elixir
@spec nullif(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns null if both values are equal.

Spark SQL function: `nullif`

# `nullifzero`

```elixir
@spec nullifzero(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns null if value is zero.

Spark SQL function: `nullifzero`

# `nvl2`

```elixir
@spec nvl2(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Returns second if first is not null, else third.

Spark SQL function: `nvl2`

# `nvl`

```elixir
@spec nvl(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns second value if first is null.

Spark SQL function: `nvl`

# `octet_length`

```elixir
@spec octet_length(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns byte length of string.

Spark SQL function: `octet_length`

# `otherwise`

```elixir
@spec otherwise(SparkEx.Column.t(), SparkEx.Column.t() | term()) :: SparkEx.Column.t()
```

Adds a fallback value to a `when_/2` expression chain.

## Examples

    when_(col("score") |> Column.gt(90), lit("A"))
    |> otherwise(lit("B"))

# `overlay`

```elixir
@spec overlay(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t() | integer()
) :: SparkEx.Column.t()
```

Overlays `replace` over `src` starting at `pos` for `len` characters.

All arguments accept Column or string column names.
`len` defaults to `-1` (replace entire match length).

# `parse_json`

```elixir
@spec parse_json(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback: parse JSON text as generic JSON string value.

# `parse_url`

```elixir
@spec parse_url(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t() | nil
) :: SparkEx.Column.t()
```

Extracts a part of a URL. Optional key for query string extraction.

# `percent_rank`

```elixir
@spec percent_rank() :: SparkEx.Column.t()
```

Percent rank within partition.

Spark SQL function: `percent_rank`

# `percentile`

```elixir
@spec percentile(
  SparkEx.Column.t() | String.t(),
  number() | [number()],
  SparkEx.Column.t() | integer()
) ::
  SparkEx.Column.t()
```

Exact percentile. Supports single percentage or list/array of percentages.

Optional frequency parameter (default 1).

# `percentile_approx`

```elixir
@spec percentile_approx(SparkEx.Column.t() | String.t(), term(), term()) ::
  SparkEx.Column.t()
```

Approximate percentile.

Spark SQL function: `percentile_approx`

# `pi`

```elixir
@spec pi() :: SparkEx.Column.t()
```

Returns pi.

Spark SQL function: `pi`

# `pmod`

```elixir
@spec pmod(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Positive modulo.

Spark SQL function: `pmod`

# `posexplode`

```elixir
@spec posexplode(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Like explode but includes position.

Spark SQL function: `posexplode`

# `posexplode_outer`

```elixir
@spec posexplode_outer(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Like posexplode but preserves nulls.

Spark SQL function: `posexplode_outer`

# `position`

```elixir
@spec position(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Returns position of substring.

Spark SQL function: `position`

# `positive`

```elixir
@spec positive(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns positive value.

Spark SQL function: `positive`

# `pow`

```elixir
@spec pow(
  SparkEx.Column.t() | String.t() | number(),
  SparkEx.Column.t() | String.t() | number()
) ::
  SparkEx.Column.t()
```

Computes x raised to the power of y. Both arguments can be columns or numeric values.

# `power`

```elixir
@spec power(
  SparkEx.Column.t() | String.t() | number(),
  SparkEx.Column.t() | String.t() | number()
) ::
  SparkEx.Column.t()
```

Alias for `pow/2`.

# `printf`

```elixir
@spec printf(
  term(),
  SparkEx.Column.t() | String.t() | [SparkEx.Column.t() | String.t()]
) ::
  SparkEx.Column.t()
```

Alias for `format_string/2`.

# `product`

```elixir
@spec product(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes product of all values.

Spark SQL function: `product`

# `quarter`

```elixir
@spec quarter(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts quarter.

Spark SQL function: `quarter`

# `quote_`

```elixir
@spec quote_(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Quotes a string for use in SQL.

Spark SQL function: `quote`

# `radians`

```elixir
@spec radians(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Converts degrees to radians.

Spark SQL function: `radians`

# `raise_error`

```elixir
@spec raise_error(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Raises a user-specified error message.

Spark SQL function: `raise_error`

# `rand`

```elixir
@spec rand(integer() | nil | keyword()) :: SparkEx.Column.t()
```

Random value in [0, 1). Auto-generates a random seed when none given.
Pass an explicit seed for reproducible results.

# `randn`

```elixir
@spec randn(integer() | nil | keyword()) :: SparkEx.Column.t()
```

Random value from standard normal distribution. Auto-generates a random seed when none given.
Pass an explicit seed for reproducible results.

# `randstr`

```elixir
@spec randstr(SparkEx.Column.t() | String.t(), term(), integer() | nil) ::
  SparkEx.Column.t()
```

Generates random string of given length. Auto-generates seed when none given.

# `rank`

```elixir
@spec rank() :: SparkEx.Column.t()
```

Rank within partition.

Spark SQL function: `rank`

# `reduce`

```elixir
@spec reduce(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | term(),
  (SparkEx.Column.t(), SparkEx.Column.t() -> SparkEx.Column.t()),
  (SparkEx.Column.t() -> SparkEx.Column.t()) | nil
) :: SparkEx.Column.t()
```

Alias for `aggregate/3`.

# `reflect_`

```elixir
@spec reflect_([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Calls a JVM method via reflection.

Spark SQL function: `reflect`

# `regexp`

```elixir
@spec regexp(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Alias for `regexp_like/2`.

# `regexp_count`

```elixir
@spec regexp_count(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Counts regex pattern occurrences.

Spark SQL function: `regexp_count`

# `regexp_extract`

```elixir
@spec regexp_extract(SparkEx.Column.t() | String.t(), term(), term()) ::
  SparkEx.Column.t()
```

Extracts regex group.

Spark SQL function: `regexp_extract`

# `regexp_extract_all`

```elixir
@spec regexp_extract_all(SparkEx.Column.t() | String.t(), term(), term()) ::
  SparkEx.Column.t()
```

Extracts all matches for regex group.

Spark SQL function: `regexp_extract_all`

# `regexp_instr`

```elixir
@spec regexp_instr(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Returns position of first regex match.

Spark SQL function: `regexp_instr`

# `regexp_like`

```elixir
@spec regexp_like(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Returns true if column matches regex.

Spark SQL function: `regexp_like`

# `regexp_replace`

```elixir
@spec regexp_replace(SparkEx.Column.t() | String.t(), term(), term()) ::
  SparkEx.Column.t()
```

Replaces regex matches.

Spark SQL function: `regexp_replace`

# `regexp_substr`

```elixir
@spec regexp_substr(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Returns first substring matching regex.

Spark SQL function: `regexp_substr`

# `regr_avgx`

```elixir
@spec regr_avgx(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Average of independent variable.

Spark SQL function: `regr_avgx`

# `regr_avgy`

```elixir
@spec regr_avgy(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Average of dependent variable.

Spark SQL function: `regr_avgy`

# `regr_count`

```elixir
@spec regr_count(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Count of non-null pairs.

Spark SQL function: `regr_count`

# `regr_intercept`

```elixir
@spec regr_intercept(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Y-intercept of regression line.

Spark SQL function: `regr_intercept`

# `regr_r2`

```elixir
@spec regr_r2(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Coefficient of determination.

Spark SQL function: `regr_r2`

# `regr_slope`

```elixir
@spec regr_slope(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Slope of regression line.

Spark SQL function: `regr_slope`

# `regr_sxx`

```elixir
@spec regr_sxx(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Sum of squares of independent variable.

Spark SQL function: `regr_sxx`

# `regr_sxy`

```elixir
@spec regr_sxy(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Sum of products of deviations.

Spark SQL function: `regr_sxy`

# `regr_syy`

```elixir
@spec regr_syy(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Sum of squares of dependent variable.

Spark SQL function: `regr_syy`

# `repeat`

```elixir
@spec repeat(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Repeats string n times.

Spark SQL function: `repeat`

# `replace`

```elixir
@spec replace(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Replaces occurrences of search string. When `replacement` is omitted, uses empty string.

# `reverse`

```elixir
@spec reverse(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Reverses string or array.

Spark SQL function: `reverse`

# `right_`

```elixir
@spec right_(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns rightmost n characters.

Spark SQL function: `right`

# `rint`

```elixir
@spec rint(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Rounds to nearest integer.

Spark SQL function: `rint`

# `rlike_`

```elixir
@spec rlike_(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Regex pattern match.

Spark SQL function: `rlike`

# `round`

```elixir
@spec round(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Rounds to `scale` decimal places.

Spark SQL function: `round`

# `row_number`

```elixir
@spec row_number() :: SparkEx.Column.t()
```

Row number within partition.

Spark SQL function: `row_number`

# `rpad`

```elixir
@spec rpad(SparkEx.Column.t() | String.t(), term(), term()) :: SparkEx.Column.t()
```

Right-pads string to length with pad string.

Spark SQL function: `rpad`

# `rtrim`

```elixir
@spec rtrim(SparkEx.Column.t() | String.t(), String.t() | nil) :: SparkEx.Column.t()
```

Right-trims whitespace or specified characters.

# `schema_of_csv`

```elixir
@spec schema_of_csv(SparkEx.Column.t() | String.t(), map() | nil) ::
  SparkEx.Column.t()
```

Returns DDL schema string of CSV string. Accepts optional options map.

# `schema_of_json`

```elixir
@spec schema_of_json(SparkEx.Column.t() | String.t(), map() | nil) ::
  SparkEx.Column.t()
```

Returns DDL schema string of JSON string. Accepts optional options map.

# `schema_of_variant`

```elixir
@spec schema_of_variant(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for schema_of_variant/1.

# `schema_of_variant_agg`

```elixir
@spec schema_of_variant_agg(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for schema_of_variant_agg/1.

# `schema_of_xml`

```elixir
@spec schema_of_xml(SparkEx.Column.t() | String.t(), map() | nil) ::
  SparkEx.Column.t()
```

Returns DDL schema string of XML string. Accepts optional options map.

# `sec`

```elixir
@spec sec(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes secant.

Spark SQL function: `sec`

# `second`

```elixir
@spec second(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts second.

Spark SQL function: `second`

# `sentences`

```elixir
@spec sentences(SparkEx.Column.t() | String.t(), String.t() | nil, String.t() | nil) ::
  SparkEx.Column.t()
```

Splits text into array of sentences.

Optionally accepts language and country parameters.

## Examples

    sentences(col("text"))
    sentences(col("text"), "en", "US")

# `sequence`

```elixir
@spec sequence(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t() | nil
) :: SparkEx.Column.t()
```

Creates array of values from start to stop with optional step.

## Examples

    sequence(col("start"), col("stop"))
    sequence(col("start"), col("stop"), col("step"))

# `session_user_`

```elixir
@spec session_user_() :: SparkEx.Column.t()
```

Returns session user name.

Spark SQL function: `session_user`

# `session_window`

```elixir
@spec session_window(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Generates session window for streaming aggregations.

Spark SQL function: `session_window`

# `sha1`

```elixir
@spec sha1(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

SHA-1 hash.

Spark SQL function: `sha1`

# `sha2`

```elixir
@spec sha2(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

SHA-2 hash with bit length.

Spark SQL function: `sha2`

# `sha`

```elixir
@spec sha(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `sha1/1`.

# `shiftleft`

```elixir
@spec shiftleft(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Bitwise left shift.

Spark SQL function: `shiftleft`

# `shiftright`

```elixir
@spec shiftright(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Bitwise right shift.

Spark SQL function: `shiftright`

# `shiftrightunsigned`

```elixir
@spec shiftrightunsigned(SparkEx.Column.t() | String.t(), term()) ::
  SparkEx.Column.t()
```

Bitwise unsigned right shift.

Spark SQL function: `shiftrightunsigned`

# `shuffle`

```elixir
@spec shuffle(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns randomly shuffled array. Optional `seed` parameter.

# `shuffle`

```elixir
@spec shuffle(SparkEx.Column.t() | String.t(), integer()) :: SparkEx.Column.t()
```

# `sign`

```elixir
@spec sign(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `signum/1`.

# `signum`

```elixir
@spec signum(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes sign.

Spark SQL function: `signum`

# `sin`

```elixir
@spec sin(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes sine.

Spark SQL function: `sin`

# `sinh`

```elixir
@spec sinh(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes hyperbolic sine.

Spark SQL function: `sinh`

# `size`

```elixir
@spec size(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns size of array or map.

Spark SQL function: `size`

# `skewness`

```elixir
@spec skewness(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Skewness.

Spark SQL function: `skewness`

# `slice`

```elixir
@spec slice(SparkEx.Column.t() | String.t(), term(), term()) :: SparkEx.Column.t()
```

Returns slice of array from start for length.

Spark SQL function: `slice`

# `some`

```elixir
@spec some(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `bool_or/1`.

# `sort_array`

```elixir
@spec sort_array(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Sorts array.

Spark SQL function: `sort_array`

# `soundex`

```elixir
@spec soundex(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Soundex code.

Spark SQL function: `soundex`

# `spark_partition_id`

```elixir
@spec spark_partition_id() :: SparkEx.Column.t()
```

Partition ID of each row.

Spark SQL function: `spark_partition_id`

# `split`

```elixir
@spec split(SparkEx.Column.t() | String.t(), String.t(), integer() | nil) ::
  SparkEx.Column.t()
```

Splits string by regex pattern.

## Examples

    split(col("s"), "\\.")
    split(col("s"), "\\.", 3)

# `split_part`

```elixir
@spec split_part(SparkEx.Column.t() | String.t(), term(), term()) ::
  SparkEx.Column.t()
```

Splits string and returns the field at index.

Spark SQL function: `split_part`

# `sqrt`

```elixir
@spec sqrt(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes square root.

Spark SQL function: `sqrt`

# `st_asbinary`

```elixir
@spec st_asbinary(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Converts geometry/geography to WKB binary.

Spark SQL function: `ST_AsBinary`

# `st_geogfromwkb`

```elixir
@spec st_geogfromwkb(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates geography from WKB binary.

Spark SQL function: `ST_GeogFromWKB`

# `st_geomfromwkb`

```elixir
@spec st_geomfromwkb(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates geometry from WKB binary.

Spark SQL function: `ST_GeomFromWKB`

# `st_setsrid`

```elixir
@spec st_setsrid(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Sets the SRID of a geometry.

Spark SQL function: `ST_SetSRID`

# `st_srid`

```elixir
@spec st_srid(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns the SRID of a geometry.

Spark SQL function: `ST_SRID`

# `stack`

```elixir
@spec stack([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Separates column into n rows.

Spark SQL function: `stack`

# `star`

```elixir
@spec star() :: SparkEx.Column.t()
```

Creates an unresolved star (*) expression for selecting all columns.

# `startswith`

```elixir
@spec startswith(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns true if string starts with prefix.

Spark SQL function: `startsWith`

# `std`

```elixir
@spec std(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `stddev/1`.

# `stddev`

```elixir
@spec stddev(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Sample standard deviation.

Spark SQL function: `stddev`

# `stddev_pop`

```elixir
@spec stddev_pop(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Population standard deviation.

Spark SQL function: `stddev_pop`

# `stddev_samp`

```elixir
@spec stddev_samp(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `stddev/1`.

# `str_to_map`

```elixir
@spec str_to_map(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Creates map from delimited string.

Spark SQL function: `str_to_map`

# `string_agg`

```elixir
@spec string_agg(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Alias for `listagg/2`.

# `string_agg_distinct`

```elixir
@spec string_agg_distinct(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Alias for `listagg_distinct/2`.

# `struct`

```elixir
@spec struct([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Creates struct from columns.

Spark SQL function: `struct`

# `substr_`

```elixir
@spec substr_(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t() | nil
) :: SparkEx.Column.t()
```

Returns substring from pos. Optional len parameter.

# `substring`

```elixir
@spec substring(SparkEx.Column.t() | String.t(), term(), term()) :: SparkEx.Column.t()
```

Returns substring from pos for len.

Spark SQL function: `substring`

# `substring_index`

```elixir
@spec substring_index(SparkEx.Column.t() | String.t(), term(), term()) ::
  SparkEx.Column.t()
```

Returns substring before count occurrences of delimiter.

Spark SQL function: `substring_index`

# `sum`

```elixir
@spec sum(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes sum.

Spark SQL function: `sum`

# `sum_distinct`

```elixir
@spec sum_distinct(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes sum of distinct values.

Spark SQL function: `sum`

# `tan`

```elixir
@spec tan(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes tangent.

Spark SQL function: `tan`

# `tanh`

```elixir
@spec tanh(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Computes hyperbolic tangent.

Spark SQL function: `tanh`

# `theta_difference`

```elixir
@spec theta_difference(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Computes difference of two theta sketches.

Spark SQL function: `theta_difference`

# `theta_intersection`

```elixir
@spec theta_intersection(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Intersects two theta sketches.

Spark SQL function: `theta_intersection`

# `theta_intersection_agg`

```elixir
@spec theta_intersection_agg(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregate intersection of theta sketches.

Spark SQL function: `theta_intersection_agg`

# `theta_sketch_agg`

```elixir
@spec theta_sketch_agg(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregates values into a theta sketch.

Spark SQL function: `theta_sketch_agg`

# `theta_sketch_estimate`

```elixir
@spec theta_sketch_estimate(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Estimates distinct count from a theta sketch.

Spark SQL function: `theta_sketch_estimate`

# `theta_union`

```elixir
@spec theta_union(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Unions two theta sketches.

Spark SQL function: `theta_union`

# `theta_union_agg`

```elixir
@spec theta_union_agg(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Aggregate union of theta sketches.

Spark SQL function: `theta_union_agg`

# `time_diff`

```elixir
@spec time_diff(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Returns the difference between two times measured in the specified units.

Spark 4.1+. Unit is passed as a column expression (use `lit/1` for string literals).
Supported units: "HOUR", "MINUTE", "SECOND", "MILLISECOND", "MICROSECOND".

## Examples

    time_diff(lit("HOUR"), col("start_time"), col("end_time"))

# `time_trunc`

```elixir
@spec time_trunc(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Spark 3.5-compatible fallback for time_trunc/2.

# `timestamp_add`

```elixir
@spec timestamp_add(
  term(),
  SparkEx.Column.t() | String.t() | [SparkEx.Column.t() | String.t()]
) ::
  SparkEx.Column.t()
```

Adds interval to timestamp.

Spark SQL function: `timestampadd`

# `timestamp_diff`

```elixir
@spec timestamp_diff(
  term(),
  SparkEx.Column.t() | String.t() | [SparkEx.Column.t() | String.t()]
) ::
  SparkEx.Column.t()
```

Returns difference between timestamps in given unit.

Spark SQL function: `timestampdiff`

# `timestamp_micros`

```elixir
@spec timestamp_micros(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates timestamp from microseconds.

Spark SQL function: `timestamp_micros`

# `timestamp_millis`

```elixir
@spec timestamp_millis(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates timestamp from milliseconds.

Spark SQL function: `timestamp_millis`

# `timestamp_seconds`

```elixir
@spec timestamp_seconds(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Creates timestamp from seconds.

Spark SQL function: `timestamp_seconds`

# `to_avro`

```elixir
@spec to_avro(SparkEx.Column.t() | String.t(), String.t() | nil) :: SparkEx.Column.t()
```

Encodes a column to Avro binary using an optional JSON schema.

# `to_binary`

```elixir
@spec to_binary(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Converts to binary.

Spark SQL function: `to_binary`

# `to_char_`

```elixir
@spec to_char_(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Converts to character string with format.

Spark SQL function: `to_char`

# `to_csv`

```elixir
@spec to_csv(SparkEx.Column.t() | String.t(), map() | nil) :: SparkEx.Column.t()
```

Converts a struct column to a CSV string.

## Examples

    to_csv(col("struct_col"))
    to_csv(col("struct_col"), %{"sep" => "|"})

# `to_date`

```elixir
@spec to_date(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Converts to date, optionally with format.

Spark SQL function: `to_date`

# `to_degrees`

```elixir
@spec to_degrees(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `degrees/1`.

# `to_json`

```elixir
@spec to_json(SparkEx.Column.t() | String.t(), map() | nil) :: SparkEx.Column.t()
```

Converts a struct/array/map column to a JSON string.

## Examples

    to_json(col("struct_col"))
    to_json(col("struct_col"), %{"pretty" => "true"})

# `to_number`

```elixir
@spec to_number(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Converts string to number with format.

Spark SQL function: `to_number`

# `to_protobuf`

```elixir
@spec to_protobuf(SparkEx.Column.t() | String.t(), String.t(), keyword()) ::
  SparkEx.Column.t()
```

Encodes a column to Protobuf binary using the provided message name and descriptor.

Either `desc_file_path` or `binary_descriptor_set` can be provided (only one).

# `to_radians`

```elixir
@spec to_radians(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `radians/1`.

# `to_time`

```elixir
@spec to_time(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for to_time/1,2 via timestamp parsing and formatting.

# `to_timestamp`

```elixir
@spec to_timestamp(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Converts to timestamp, optionally with format.

Spark SQL function: `to_timestamp`

# `to_timestamp_ltz`

```elixir
@spec to_timestamp_ltz(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Converts to timestamp with local timezone.

Spark SQL function: `to_timestamp_ltz`

# `to_timestamp_ntz`

```elixir
@spec to_timestamp_ntz(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Converts to timestamp without timezone.

Spark SQL function: `to_timestamp_ntz`

# `to_unix_timestamp`

```elixir
@spec to_unix_timestamp(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Converts timestamp to unix seconds.

Spark SQL function: `to_unix_timestamp`

# `to_utc_timestamp`

```elixir
@spec to_utc_timestamp(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Converts timestamp from timezone to UTC.

Spark SQL function: `to_utc_timestamp`

# `to_varchar`

```elixir
@spec to_varchar(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Alias for `to_char_/2`.

# `to_variant_object`

```elixir
@spec to_variant_object(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for to_variant_object/1.

# `to_xml`

```elixir
@spec to_xml(SparkEx.Column.t() | String.t(), map() | nil) :: SparkEx.Column.t()
```

Converts a struct column to an XML string.

## Examples

    to_xml(col("struct_col"))
    to_xml(col("struct_col"), %{"rowTag" => "item"})

# `transform`

```elixir
@spec transform(
  SparkEx.Column.t() | String.t(),
  (SparkEx.Column.t() -> SparkEx.Column.t())
  | (SparkEx.Column.t(), SparkEx.Column.t() -> SparkEx.Column.t())
) :: SparkEx.Column.t()
```

Transforms each element in an array column using a function.

The function receives a lambda variable `x` representing each element.

## Examples

    transform(col("arr"), fn x -> Column.plus(x, lit(1)) end)

# `transform_keys`

```elixir
@spec transform_keys(SparkEx.Column.t() | String.t(), (SparkEx.Column.t(),
                                                 SparkEx.Column.t() ->
                                                   SparkEx.Column.t())) ::
  SparkEx.Column.t()
```

Transforms keys of a map column using a function on key and value.

## Examples

    transform_keys(col("m"), fn k, v -> Column.plus(k, lit(1)) end)

# `transform_values`

```elixir
@spec transform_values(SparkEx.Column.t() | String.t(), (SparkEx.Column.t(),
                                                   SparkEx.Column.t() ->
                                                     SparkEx.Column.t())) ::
  SparkEx.Column.t()
```

Transforms values of a map column using a function on key and value.

## Examples

    transform_values(col("m"), fn k, v -> Column.plus(v, lit(1)) end)

# `translate`

```elixir
@spec translate(SparkEx.Column.t() | String.t(), term(), term()) :: SparkEx.Column.t()
```

Translates characters.

Spark SQL function: `translate`

# `trim`

```elixir
@spec trim(SparkEx.Column.t() | String.t(), String.t() | nil) :: SparkEx.Column.t()
```

Trims whitespace or specified characters from both ends.

# `trunc`

```elixir
@spec trunc(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Truncates date to specified format.

Spark SQL function: `trunc`

# `try_add`

```elixir
@spec try_add(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Try addition, returns null on overflow.

Spark SQL function: `try_add`

# `try_aes_decrypt`

```elixir
@spec try_aes_decrypt([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Try AES decrypt, returns null on failure.

Spark SQL function: `try_aes_decrypt`

# `try_avg`

```elixir
@spec try_avg(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Try average, returns null on overflow.

Spark SQL function: `try_avg`

# `try_divide`

```elixir
@spec try_divide(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Try division, returns null on division by zero.

Spark SQL function: `try_divide`

# `try_element_at`

```elixir
@spec try_element_at(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Returns element at index/key, null on out of bounds.

Spark SQL function: `try_element_at`

# `try_make_interval`

```elixir
@spec try_make_interval(keyword()) :: SparkEx.Column.t()
```

Try version of `make_interval/1` — returns null on invalid input.

# `try_make_timestamp`

```elixir
@spec try_make_timestamp([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Try version of `make_timestamp/1` — returns null on invalid input.

# `try_make_timestamp_ltz`

```elixir
@spec try_make_timestamp_ltz([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Try version of `make_timestamp_ltz/1` — returns null on invalid input.

# `try_make_timestamp_ntz`

```elixir
@spec try_make_timestamp_ntz([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Try version of `make_timestamp_ntz/1` — returns null on invalid input.

# `try_mod`

```elixir
@spec try_mod(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Try modulo, returns null on division by zero.

Spark SQL function: `try_mod`

# `try_multiply`

```elixir
@spec try_multiply(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Try multiplication, returns null on overflow.

Spark SQL function: `try_multiply`

# `try_parse_json`

```elixir
@spec try_parse_json(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for try_parse_json/1.

# `try_parse_url`

```elixir
@spec try_parse_url(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t() | nil
) :: SparkEx.Column.t()
```

Try to extract a part of a URL, returns null on failure. Optional key for query string.

# `try_reflect`

```elixir
@spec try_reflect([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

Try to call a JVM method, returns null on failure.

Spark SQL function: `try_reflect`

# `try_subtract`

```elixir
@spec try_subtract(SparkEx.Column.t() | String.t(), SparkEx.Column.t() | String.t()) ::
  SparkEx.Column.t()
```

Try subtraction, returns null on overflow.

Spark SQL function: `try_subtract`

# `try_sum`

```elixir
@spec try_sum(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Try sum, returns null on overflow.

Spark SQL function: `try_sum`

# `try_to_binary`

```elixir
@spec try_to_binary(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Try to convert to binary, returns null on failure.

Spark SQL function: `try_to_binary`

# `try_to_date`

```elixir
@spec try_to_date(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Try to convert to date, returns null on failure.

Spark SQL function: `try_to_date`

# `try_to_number`

```elixir
@spec try_to_number(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Try to convert to number, returns null on failure.

Spark SQL function: `try_to_number`

# `try_to_time`

```elixir
@spec try_to_time(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for try_to_time/1,2 via try_to_timestamp.

# `try_to_timestamp`

```elixir
@spec try_to_timestamp(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

Try to convert to timestamp, returns null on failure.

Spark SQL function: `try_to_timestamp`

# `try_url_decode`

```elixir
@spec try_url_decode(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Try URL-decode, returns null on failure.

Spark SQL function: `try_url_decode`

# `try_validate_utf8`

```elixir
@spec try_validate_utf8(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Validates UTF-8 and returns null on invalid.

Spark SQL function: `try_validate_utf8`

# `try_variant_get`

```elixir
@spec try_variant_get(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for try_variant_get/3 using JSON path extraction.

# `typeof`

```elixir
@spec typeof(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Runtime data type string.

Spark SQL function: `typeof`

# `ucase`

```elixir
@spec ucase(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `upper/1`.

# `unbase64`

```elixir
@spec unbase64(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Decodes base64 string.

Spark SQL function: `unbase64`

# `unhex`

```elixir
@spec unhex(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Decodes hex string to binary.

Spark SQL function: `unhex`

# `uniform`

```elixir
@spec uniform(SparkEx.Column.t() | String.t(), term(), integer() | nil) ::
  SparkEx.Column.t()
```

Random value uniformly distributed in [min, max). Auto-generates seed when none given.

# `unix_date`

```elixir
@spec unix_date(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns days since epoch for date.

Spark SQL function: `unix_date`

# `unix_micros`

```elixir
@spec unix_micros(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns microseconds since epoch.

Spark SQL function: `unix_micros`

# `unix_millis`

```elixir
@spec unix_millis(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns milliseconds since epoch.

Spark SQL function: `unix_millis`

# `unix_seconds`

```elixir
@spec unix_seconds(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns seconds since epoch.

Spark SQL function: `unix_seconds`

# `unix_timestamp`

```elixir
@spec unix_timestamp() :: SparkEx.Column.t()
```

Converts timestamp to unix seconds. Can be called with no args for current timestamp.

# `unix_timestamp`

```elixir
@spec unix_timestamp(
  SparkEx.Column.t() | String.t(),
  keyword()
) :: SparkEx.Column.t()
```

# `unwrap_udt`

```elixir
@spec unwrap_udt(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns the value of a user-defined type (UDT) as its underlying SQL representation.

# `upper`

```elixir
@spec upper(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Converts to uppercase.

Spark SQL function: `upper`

# `url_decode`

```elixir
@spec url_decode(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

URL-decodes string.

Spark SQL function: `url_decode`

# `url_encode`

```elixir
@spec url_encode(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

URL-encodes string.

Spark SQL function: `url_encode`

# `user_`

```elixir
@spec user_() :: SparkEx.Column.t()
```

Alias for `current_user_/0`.

# `uuid`

```elixir
@spec uuid() :: SparkEx.Column.t()
```

Generates a random UUID string.

# `uuid`

```elixir
@spec uuid(integer()) :: SparkEx.Column.t()
```

Generates a random UUID string with deterministic seed (Spark 4.x+).

# `validate_utf8`

```elixir
@spec validate_utf8(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Validates UTF-8 and raises on invalid.

Spark SQL function: `validate_utf8`

# `var_pop`

```elixir
@spec var_pop(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Population variance.

Spark SQL function: `var_pop`

# `var_samp`

```elixir
@spec var_samp(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Alias for `variance/1`.

# `variance`

```elixir
@spec variance(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Sample variance.

Spark SQL function: `variance`

# `variant_get`

```elixir
@spec variant_get(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t()
) :: SparkEx.Column.t()
```

Spark 3.5-compatible fallback for variant_get/3 using JSON path extraction.

# `version_`

```elixir
@spec version_() :: SparkEx.Column.t()
```

Returns Spark version string.

Spark SQL function: `version`

# `weekday`

```elixir
@spec weekday(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Day of week (0=Mon, 6=Sun).

Spark SQL function: `weekday`

# `weekofyear`

```elixir
@spec weekofyear(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Week of year.

Spark SQL function: `weekofyear`

# `when_`

```elixir
@spec when_(SparkEx.Column.t(), SparkEx.Column.t() | term()) :: SparkEx.Column.t()
```

Evaluates a list of conditions and returns one of multiple possible result expressions.
If `otherwise/2` is not used, nil is returned for unmatched conditions.

Equivalent to `CASE WHEN condition THEN value END` in SQL.

## Examples

    import SparkEx.Functions

    when_(col("age") |> Column.lt(13), lit("child"))
    |> otherwise(lit("adult"))

# `width_bucket`

```elixir
@spec width_bucket(SparkEx.Column.t() | String.t(), term(), term(), term()) ::
  SparkEx.Column.t()
```

Returns bucket number for value in equi-width histogram.

Spark SQL function: `width_bucket`

# `window`

```elixir
@spec window(
  SparkEx.Column.t() | String.t(),
  String.t(),
  String.t() | nil,
  String.t() | nil
) ::
  SparkEx.Column.t()
```

Generates tumbling or sliding time window column for streaming aggregations.

## Examples

    window(col("timestamp"), "10 minutes")
    window(col("timestamp"), "10 minutes", "5 minutes")
    window(col("timestamp"), "10 minutes", "5 minutes", "2 minutes")

# `window_time`

```elixir
@spec window_time(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts the time column from a window column.

Spark SQL function: `window_time`

# `xpath`

```elixir
@spec xpath(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning array of strings.

Spark SQL function: `xpath`

# `xpath_boolean`

```elixir
@spec xpath_boolean(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning boolean.

Spark SQL function: `xpath_boolean`

# `xpath_double`

```elixir
@spec xpath_double(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning double.

Spark SQL function: `xpath_double`

# `xpath_float`

```elixir
@spec xpath_float(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning float.

Spark SQL function: `xpath_float`

# `xpath_int`

```elixir
@spec xpath_int(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning integer.

Spark SQL function: `xpath_int`

# `xpath_long`

```elixir
@spec xpath_long(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning long.

Spark SQL function: `xpath_long`

# `xpath_number`

```elixir
@spec xpath_number(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Alias for `xpath_double/2`.

# `xpath_short`

```elixir
@spec xpath_short(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning short.

Spark SQL function: `xpath_short`

# `xpath_string`

```elixir
@spec xpath_string(SparkEx.Column.t() | String.t(), term()) :: SparkEx.Column.t()
```

Evaluates XPath expression returning string.

Spark SQL function: `xpath_string`

# `xxhash64`

```elixir
@spec xxhash64([SparkEx.Column.t() | String.t()]) :: SparkEx.Column.t()
```

xxHash64 of columns.

Spark SQL function: `xxhash64`

# `year`

```elixir
@spec year(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts year.

Spark SQL function: `year`

# `years`

```elixir
@spec years(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Extracts years from an interval expression.

# `zeroifnull`

```elixir
@spec zeroifnull(SparkEx.Column.t() | String.t()) :: SparkEx.Column.t()
```

Returns zero if value is null.

Spark SQL function: `zeroifnull`

# `zip_with`

```elixir
@spec zip_with(
  SparkEx.Column.t() | String.t(),
  SparkEx.Column.t() | String.t(),
  (SparkEx.Column.t(), SparkEx.Column.t() -> SparkEx.Column.t())
) :: SparkEx.Column.t()
```

Merges two arrays element-wise using a function.

## Examples

    zip_with(col("a1"), col("a2"), fn x, y -> Column.plus(x, y) end)

---

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