diff --git a/py-polars/docs/source/reference/index.rst b/py-polars/docs/source/reference/index.rst
index ebd0eaf005e3..c662f96a0f94 100644
--- a/py-polars/docs/source/reference/index.rst
+++ b/py-polars/docs/source/reference/index.rst
@@ -91,7 +91,7 @@ methods. All classes and functions exposed in the ``polars.*`` namespace are pub
         .. toctree::
            :maxdepth: 2
 
-           sql
+           sql/index
 
     .. grid-item-card::
 
diff --git a/py-polars/docs/source/reference/sql/clauses.rst b/py-polars/docs/source/reference/sql/clauses.rst
new file mode 100644
index 000000000000..0625f2aba6a4
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/clauses.rst
@@ -0,0 +1,311 @@
+SQL Clauses
+===========
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`SELECT <select>`
+     - Retrieves specific column data from one or more tables.
+   * - :ref:`FROM <from>`
+     - Specify the table(s) from which to retrieve or delete data.
+   * - :ref:`JOIN <join>`
+     - Combine rows from two or more tables based on a related column.
+   * - :ref:`WHERE <where>`
+     - Filter rows returned from the query based on specific condition(s).
+   * - :ref:`GROUP BY <group_by>`
+     - Aggregate row values based based on one or more key columns.
+   * - :ref:`HAVING <having>`
+     - Filter groups in a `GROUP BY` based on specific condition(s).
+   * - :ref:`ORDER BY <order_by>`
+     - Sort the query result based on one or more specified columns.
+   * - :ref:`LIMIT <limit>`
+     - Specify the number of rows returned.
+   * - :ref:`OFFSET <offset>`
+     - Skip a specified number of rows.
+
+
+.. _select:
+
+SELECT
+------
+Select the columns to be returned by the query.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [1, 2, 3],
+        "b": ["zz", "yy", "xx"],
+      }
+    )
+    df.sql("""
+      SELECT a, b FROM self
+    """)
+    # shape: (3, 2)
+    # ┌─────┬─────┐
+    # │ a   ┆ b   │
+    # │ --- ┆ --- │
+    # │ i64 ┆ str │
+    # ╞═════╪═════╡
+    # │ 1   ┆ zz  │
+    # │ 2   ┆ yy  │
+    # │ 3   ┆ xx  │
+    # └─────┴─────┘
+
+.. _from:
+
+FROM
+----
+Specifies the table(s) from which to retrieve or delete data.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [1, 2, 3],
+        "b": ["zz", "yy", "xx"],
+      }
+    )
+    df.sql("""
+      SELECT * FROM self
+    """)
+    # shape: (3, 2)
+    # ┌─────┬─────┐
+    # │ a   ┆ b   │
+    # │ --- ┆ --- │
+    # │ i64 ┆ str │
+    # ╞═════╪═════╡
+    # │ 1   ┆ zz  │
+    # │ 2   ┆ yy  │
+    # │ 3   ┆ xx  │
+    # └─────┴─────┘
+
+.. _join:
+
+JOIN
+----
+Combines rows from two or more tables based on a related column. 
+
+**Join Types**
+
+* `CROSS JOIN`
+* `FULL JOIN`
+* `INNER JOIN`
+* `LEFT JOIN`
+* `[LEFT] ANTI JOIN`
+* `[LEFT] SEMI JOIN`
+* `RIGHT ANTI JOIN`
+* `RIGHT SEMI JOIN`
+
+**Example:**
+
+.. code-block:: python
+
+    df1 = pl.DataFrame(
+      {
+        "foo": [1, 2, 3],
+        "ham": ["a", "b", "c"],
+      }
+    )
+    df2 = pl.DataFrame(
+      {
+        "apple": ["x", "y", "z"],
+        "ham": ["a", "b", "d"],
+      }
+    )
+    pl.sql("""
+      SELECT foo, apple, COALESCE(df1.ham, df2.ham) AS ham
+      FROM df1 FULL JOIN df2
+      USING (ham)
+    """).collect()
+
+    # shape: (4, 3)
+    # ┌──────┬───────┬─────┐
+    # │ foo  ┆ apple ┆ ham │
+    # │ ---  ┆ ---   ┆ --- │
+    # │ i64  ┆ str   ┆ str │
+    # ╞══════╪═══════╪═════╡
+    # │ 1    ┆ x     ┆ a   │
+    # │ 2    ┆ y     ┆ b   │
+    # │ null ┆ z     ┆ d   │
+    # │ 3    ┆ null  ┆ c   │
+    # └──────┴───────┴─────┘
+
+.. _where:
+
+WHERE
+-----
+
+Filter rows returned from the query based on specific condition(s).
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [30, 40, 50],
+        "ham": ["a", "b", "c"],
+      }
+    )
+    df.sql("""
+      SELECT * FROM self WHERE foo > 42
+    """)
+    # shape: (1, 2)
+    # ┌─────┬─────┐
+    # │ foo ┆ ham │
+    # │ --- ┆ --- │
+    # │ i64 ┆ str │
+    # ╞═════╪═════╡
+    # │ 50  ┆ c   │
+    # └─────┴─────┘
+
+.. _group_by:
+
+GROUP BY
+--------
+Group rows that have the same values in specified columns into summary rows.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+        {
+          "foo": ["a", "b", "b"],
+          "bar": [10, 20, 30],
+        }
+      )
+    df.sql("""
+      SELECT foo, SUM(bar) FROM self GROUP BY foo
+    """)
+    # shape: (2, 2)
+    # ┌─────┬─────┐
+    # │ foo ┆ bar │
+    # │ --- ┆ --- │
+    # │ str ┆ i64 │
+    # ╞═════╪═════╡
+    # │ b   ┆ 50  │
+    # │ a   ┆ 10  │
+    # └─────┴─────┘
+
+.. _having:
+
+HAVING
+------
+Filter groups in a `GROUP BY` based on specific condition(s).
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+          {
+          "foo": ["a", "b", "b", "c"],
+          "bar": [10, 20, 30, 40],
+        }
+      )
+    df.sql("""
+      SELECT foo, SUM(bar) FROM self GROUP BY foo HAVING bar >= 40
+    """)
+    # shape: (2, 2)
+    # ┌─────┬─────┐
+    # │ foo ┆ bar │
+    # │ --- ┆ --- │
+    # │ str ┆ i64 │
+    # ╞═════╪═════╡
+    # │ c   ┆ 40  │
+    # │ b   ┆ 50  │
+    # └─────┴─────┘
+
+.. _order_by:
+
+ORDER BY
+--------
+Sort the query result based on one or more specified columns.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["b", "a", "c", "b"],
+        "bar": [20, 10, 40, 30],
+      }
+    )
+    df.sql("""
+      SELECT foo, bar FROM self ORDER BY bar DESC
+    """)
+    # shape: (4, 2)
+    # ┌─────┬─────┐
+    # │ foo ┆ bar │
+    # │ --- ┆ --- │
+    # │ str ┆ i64 │
+    # ╞═════╪═════╡
+    # │ c   ┆ 40  │
+    # │ b   ┆ 30  │
+    # │ b   ┆ 20  │
+    # │ a   ┆ 10  │
+    # └─────┴─────┘
+
+.. _limit:
+
+LIMIT
+-----
+Limit the number of rows returned by the query.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["b", "a", "c", "b"],
+        "bar": [20, 10, 40, 30],
+      }
+    )
+    df.sql("""
+      SELECT foo, bar FROM self LIMIT 2
+    """)
+    # shape: (2, 2)
+    # ┌─────┬─────┐
+    # │ foo ┆ bar │
+    # │ --- ┆ --- │
+    # │ str ┆ i64 │
+    # ╞═════╪═════╡
+    # │ b   ┆ 20  │
+    # │ a   ┆ 10  │
+    # └─────┴─────┘
+
+.. _offset:
+
+OFFSET
+------
+Skip a number of rows before starting to return rows from the query.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["b", "a", "c", "b"],
+        "bar": [20, 10, 40, 30],
+      }
+    )
+    df.sql("""
+      SELECT foo, bar FROM self LIMIT 2 OFFSET 2
+    """)
+    # shape: (2, 2)
+    # ┌─────┬─────┐
+    # │ foo ┆ bar │
+    # │ --- ┆ --- │
+    # │ str ┆ i64 │
+    # ╞═════╪═════╡
+    # │ c   ┆ 40  │
+    # │ b   ┆ 30  │
+    # └─────┴─────┘
diff --git a/py-polars/docs/source/reference/sql/functions/aggregate.rst b/py-polars/docs/source/reference/sql/functions/aggregate.rst
new file mode 100644
index 000000000000..24ba45d6cf12
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/aggregate.rst
@@ -0,0 +1,284 @@
+Aggregate
+=========
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`AVG <avg>`
+     - Returns the average (mean) of all the elements in the grouping.
+   * - :ref:`COUNT <count>`
+     - Returns the amount of elements in the grouping.
+   * - :ref:`FIRST <first>`
+     - Returns the first element of the grouping.
+   * - :ref:`LAST <last>`
+     - Returns the last element of the grouping.
+   * - :ref:`MAX <max>`
+     - Returns the greatest (maximum) of all the elements in the grouping.
+   * - :ref:`MEDIAN <median>`
+     - Returns the median element from the grouping.
+   * - :ref:`MIN <min>`
+     - Returns the smallest (minimum) of all the elements in the grouping.
+   * - :ref:`STDDEV <stddev>`
+     - Returns the standard deviation of all the elements in the grouping.
+   * - :ref:`SUM <sum>`
+     - Returns the sum of all the elements in the grouping.
+   * - :ref:`VARIANCE <variance>`
+     - Returns the variance of all the elements in the grouping.
+
+.. _avg:
+
+AVG
+---
+Returns the average (mean) of all the elements in the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"bar": [20, 10, 30, 40]})
+    df.sql("""
+      SELECT AVG(bar) AS bar_avg FROM self
+    """)
+    # shape: (1, 1)
+    # ┌─────────┐
+    # │ bar_avg │
+    # │ ---     │
+    # │ f64     │
+    # ╞═════════╡
+    # │ 25.0    │
+    # └─────────┘
+
+.. _count:
+
+COUNT
+-----
+Returns the amount of elements in the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["b", "a", "b", "c"],
+        "bar": [20, 10, 30, 40]
+      }
+    )
+    df.sql("""
+      SELECT
+        COUNT(bar) AS n_bar,
+        COUNT(DISTINCT foo) AS n_foo_unique
+      FROM self
+    """)
+
+    # shape: (1, 2)
+    # ┌───────┬──────────────┐
+    # │ n_bar ┆ n_foo_unique │
+    # │ ---   ┆ ---          │
+    # │ u32   ┆ u32          │
+    # ╞═══════╪══════════════╡
+    # │ 4     ┆ 3            │
+    # └───────┴──────────────┘
+
+.. _first:
+
+FIRST
+-----
+Returns the first element of the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["b", "a", "b", "c"]})
+    df.sql("""
+      SELECT FIRST(foo) AS ff FROM self
+    """)
+    # shape: (1, 1)
+    # ┌─────┐
+    # │ ff  │
+    # │ --- │
+    # │ str │
+    # ╞═════╡
+    # │ b   │
+    # └─────┘
+
+.. _last:
+
+LAST
+----
+Returns the last element of the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["b", "a", "b", "c"]})
+    df.sql("""
+      SELECT LAST(foo) AS lf FROM self
+    """)
+    # shape: (1, 1)
+    # ┌─────┐
+    # │ lf  │
+    # │ --- │
+    # │ str │
+    # ╞═════╡
+    # │ c   │
+    # └─────┘
+
+.. _max:
+
+MAX
+---
+Returns the greatest (maximum) of all the elements in the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"bar": [20, 10, 30, 40]})
+    df.sql("""
+      SELECT MAX(bar) AS bar_max FROM self
+    """)
+    # shape: (1, 1)
+    # ┌─────────┐
+    # │ bar_max │
+    # │ ---     │
+    # │ i64     │
+    # ╞═════════╡
+    # │ 40      │
+    # └─────────┘
+
+.. _median:
+
+MEDIAN
+------
+Returns the median element from the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"bar": [20, 10, 30, 40]})
+    df.sql("""
+      SELECT MEDIAN(bar) AS bar_median FROM self
+    """)
+    # shape: (1, 1)
+    # ┌────────────┐
+    # │ bar_median │
+    # │ ---        │
+    # │ f64        │
+    # ╞════════════╡
+    # │ 25.0       │
+    # └────────────┘
+
+.. _min:
+
+MIN
+---
+Returns the smallest (minimum) of all the elements in the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"bar": [20, 10, 30, 40]})
+    df.sql("""
+      SELECT MIN(bar) AS bar_min FROM self
+    """)
+    # shape: (1, 1)
+    # ┌─────────┐
+    # │ bar_min │
+    # │ ---     │
+    # │ i64     │
+    # ╞═════════╡
+    # │ 10      │
+    # └─────────┘
+
+.. _stddev:
+
+STDDEV
+------
+Returns the standard deviation of all the elements in the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+        {
+            "foo": [10, 20, 8],
+            "bar": [10, 7, 18],
+        }
+    )
+    df.sql("""
+      SELECT STDDEV(foo) AS foo_std, STDDEV(bar) AS bar_std FROM self
+    """)
+    # shape: (1, 2)
+    # ┌──────────┬──────────┐
+    # │ foo_std  ┆ bar_std  │
+    # │ ---      ┆ ---      │
+    # │ f64      ┆ f64      │
+    # ╞══════════╪══════════╡
+    # │ 6.429101 ┆ 5.686241 │
+    # └──────────┴──────────┘
+
+.. _sum:
+
+SUM
+---
+Returns the sum of all the elements in the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+        {
+            "foo": [1, 2, 3],
+            "bar": [6, 7, 8],
+            "ham": ["a", "b", "c"],
+        }
+    )
+    df.sql("""
+      SELECT SUM(foo) AS foo_sum, SUM(bar) AS bar_sum FROM self
+    """)
+    # shape: (1, 2)
+    # ┌─────────┬─────────┐
+    # │ foo_sum ┆ bar_sum │
+    # │ ---     ┆ ---     │
+    # │ i64     ┆ i64     │
+    # ╞═════════╪═════════╡
+    # │ 6       ┆ 21      │
+    # └─────────┴─────────┘
+
+.. _variance:
+
+VARIANCE
+--------
+Returns the variance of all the elements in the grouping.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+        {
+            "foo": [10, 20, 8],
+            "bar": [10, 7, 18],
+        }
+    )
+    df.sql("""
+      SELECT VARIANCE(foo) AS foo_var, VARIANCE(bar) AS bar_var FROM self
+    """)
+    # shape: (1, 2)
+    # ┌───────────┬───────────┐
+    # │ foo_var   ┆ bar_var   │
+    # │ ---       ┆ ---       │
+    # │ f64       ┆ f64       │
+    # ╞═══════════╪═══════════╡
+    # │ 41.333333 ┆ 32.333333 │
+    # └───────────┴───────────┘
diff --git a/py-polars/docs/source/reference/sql/functions/array.rst b/py-polars/docs/source/reference/sql/functions/array.rst
new file mode 100644
index 000000000000..01674937fa79
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/array.rst
@@ -0,0 +1,353 @@
+Array
+=====
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`ARRAY_CONTAINS <array_contains>`
+     - Returns true if the array contains the value.
+   * - :ref:`ARRAY_GET <array_get>`
+     - Returns the value at the given index in the array.
+   * - :ref:`ARRAY_LENGTH <array_length>`
+     - Returns the length of the array.
+   * - :ref:`ARRAY_LOWER <array_lower>`
+     - Returns the lower bound (min value) in an array.
+   * - :ref:`ARRAY_MEAN <array_mean>`
+     - Returns the mean of all values in an array.
+   * - :ref:`ARRAY_REVERSE <array_reverse>`
+     - Returns the array with the elements in reverse order.
+   * - :ref:`ARRAY_SUM <array_sum>`
+     - Returns the sum of all values in an array.
+   * - :ref:`ARRAY_TO_STRING <array_to_string>`
+     - Takes all elements of the array and joins them into one string.
+   * - :ref:`ARRAY_UNIQUE <array_unique>`
+     - Returns the array with the unique elements.
+   * - :ref:`ARRAY_UPPER <array_upper>`
+     - Returns the upper bound (max value) in an array.
+   * - :ref:`UNNEST <unnest>`
+     - Unnests (explodes) an array column into multiple rows.
+
+.. _array_contains:
+
+ARRAY_CONTAINS
+--------------
+Returns true if the array contains the value.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": [[1, 2], [4, 3]]})
+    df.sql("""
+      SELECT ARRAY_CONTAINS(foo, 2) FROM self
+    """)
+    # shape: (2, 1)
+    # ┌───────┐
+    # │ foo   │
+    # │ ---   │
+    # │ bool  │
+    # ╞═══════╡
+    # │ true  │
+    # │ false │
+    # └───────┘
+
+.. _array_get:
+
+ARRAY_GET
+---------
+Returns the value at the given index in the array.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [[1, 2], [4, 3, 2]],
+        "bar": [[6, 7], [8, 9, 10]]
+      }
+    )
+    df.sql("""
+      SELECT ARRAY_GET(foo, 1), ARRAY_GET(bar, 2) FROM self
+    """)
+    # shape: (2, 2)
+    # ┌─────┬──────┐
+    # │ foo ┆ bar  │
+    # │ --- ┆ ---  │
+    # │ i64 ┆ i64  │
+    # ╞═════╪══════╡
+    # │ 2   ┆ null │
+    # │ 3   ┆ 10   │
+    # └─────┴──────┘
+
+.. _array_length:
+
+ARRAY_LENGTH
+------------
+Returns the length of the array.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": [[1, 2], [4, 3, 2]]})
+    df.sql("""
+      SELECT ARRAY_LENGTH(foo) FROM self
+    """)
+    # shape: (2, 1)
+    # ┌─────┐
+    # │ foo │
+    # │ --- │
+    # │ u32 │
+    # ╞═════╡
+    # │ 2   │
+    # │ 3   │
+    # └─────┘
+
+.. _array_lower:
+
+ARRAY_LOWER
+-----------
+Returns the lower bound (min value) in an array.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [[1, 2], [4, 3, -2]],
+        "bar": [[6, 7], [8, 9, 10]]
+      }
+    )
+    df.sql("""
+      SELECT ARRAY_LOWER(foo), ARRAY_LOWER(bar) FROM self
+    """)
+    # shape: (2, 2)
+    # ┌─────┬─────┐
+    # │ foo ┆ bar │
+    # │ --- ┆ --- │
+    # │ i64 ┆ i64 │
+    # ╞═════╪═════╡
+    # │ 1   ┆ 6   │
+    # │ -2  ┆ 8   │
+    # └─────┴─────┘
+
+.. _array_mean:
+
+ARRAY_MEAN
+----------
+Returns the mean of all values in an array.
+
+**Example:**
+
+.. code-block:: python
+    
+    df = pl.DataFrame(
+      {
+        "foo": [[1, 2], [4, 3, -1]],
+        "bar": [[6, 7], [8, 9, 10]]
+      }
+    )
+    df.sql("""
+      SELECT
+        ARRAY_MEAN(foo) AS foo_mean,
+        ARRAY_MEAN(bar) AS bar_mean
+      FROM self
+    """)
+
+    # shape: (2, 2)
+    # ┌──────────┬──────────┐
+    # │ foo_mean ┆ bar_mean │
+    # │ ---      ┆ ---      │
+    # │ f64      ┆ f64      │
+    # ╞══════════╪══════════╡
+    # │ 1.5      ┆ 6.5      │
+    # │ 2.0      ┆ 9.0      │
+    # └──────────┴──────────┘
+
+.. _array_reverse:
+
+ARRAY_REVERSE
+-------------
+Returns the array with the elements in reverse order.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [[1, 2], [4, 3, 2]],
+        "bar": [[6, 7], [8, 9, 10]]
+      }
+    )
+    df.sql("""
+      SELECT
+        ARRAY_REVERSE(foo) AS oof,
+        ARRAY_REVERSE(bar) AS rab
+      FROM self
+    """)
+
+    # shape: (2, 2)
+    # ┌───────────┬────────────┐
+    # │ oof       ┆ rab        │
+    # │ ---       ┆ ---        │
+    # │ list[i64] ┆ list[i64]  │
+    # ╞═══════════╪════════════╡
+    # │ [2, 1]    ┆ [7, 6]     │
+    # │ [2, 3, 4] ┆ [10, 9, 8] │
+    # └───────────┴────────────┘
+
+.. _array_sum:
+
+ARRAY_SUM
+---------
+Returns the sum of all values in an array.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [[1, -2], [-4, 3, -2]],
+        "bar": [[-6, 7], [8, -9, 10]]
+      }
+    )
+    df.sql("""
+      SELECT
+        ARRAY_SUM(foo) AS foo_sum,
+        ARRAY_SUM(bar) AS bar_sum
+      FROM self
+    """)
+
+    # shape: (2, 2)
+    # ┌─────────┬─────────┐
+    # │ foo_sum ┆ bar_sum │
+    # │ ---     ┆ ---     │
+    # │ i64     ┆ i64     │
+    # ╞═════════╪═════════╡
+    # │ -1      ┆ 1       │
+    # │ -3      ┆ 9       │
+    # └─────────┴─────────┘
+
+.. _array_to_string:
+
+ARRAY_TO_STRING
+---------------
+Takes all elements of the array and joins them into one string.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": [["a", "b"], ["c", "d", "e"]]})
+    df.sql("""
+      SELECT ARRAY_TO_STRING(foo,',') AS foo_str FROM self
+    """)
+    # shape: (2, 1)
+    # ┌─────────┐
+    # │ foo_str │
+    # │ ---     │
+    # │ str     │
+    # ╞═════════╡
+    # │ a,b     │
+    # │ c,d,e   │
+    # └─────────┘
+
+.. _array_unique:
+
+ARRAY_UNIQUE
+------------
+Returns the array with the unique elements.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": [["a", "b"], ["b", "b", "e"]]})
+    df.sql("""
+      SELECT ARRAY_UNIQUE(foo) AS foo_unique FROM self
+    """)
+    # shape: (2, 1)
+    # ┌────────────┐
+    # │ foo_unique │
+    # │ ---        │
+    # │ list[str]  │
+    # ╞════════════╡
+    # │ ["a", "b"] │
+    # │ ["e", "b"] │
+    # └────────────┘
+
+.. _array_upper:
+
+ARRAY_UPPER
+-----------
+Returns the upper bound (max value) in an array.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [[1, 2], [4, 3, -2]],
+        "bar": [[6, 7], [8, 9, 10]]
+      }
+    )
+    df.sql("""
+      SELECT
+        ARRAY_UPPER(foo) AS foo_max,
+        ARRAY_UPPER(bar) AS bar_max
+      FROM self
+    """)
+
+    # shape: (2, 2)
+    # ┌─────────┬─────────┐
+    # │ foo_max ┆ bar_max │
+    # │ ---     ┆ ---     │
+    # │ i64     ┆ i64     │
+    # ╞═════════╪═════════╡
+    # │ 2       ┆ 7       │
+    # │ 4       ┆ 10      │
+    # └─────────┴─────────┘
+
+.. _unnest:
+
+UNNEST
+------
+Unnest/explode an array column into multiple rows.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [["a", "b"], ["c", "d", "e"]],
+        "bar": [[6, 7, 8], [9, 10]]
+      }
+    )
+    df.sql("""
+      SELECT
+        UNNEST(foo) AS f,
+        UNNEST(bar) AS b
+      FROM self
+    """)
+
+    # shape: (5, 2)
+    # ┌─────┬─────┐
+    # │ f   ┆ b   │
+    # │ --- ┆ --- │
+    # │ str ┆ i64 │
+    # ╞═════╪═════╡
+    # │ a   ┆ 6   │
+    # │ b   ┆ 7   │
+    # │ c   ┆ 8   │
+    # │ d   ┆ 9   │
+    # │ e   ┆ 10  │
+    # └─────┴─────┘
diff --git a/py-polars/docs/source/reference/sql/functions/conditional.rst b/py-polars/docs/source/reference/sql/functions/conditional.rst
new file mode 100644
index 000000000000..aa4fcaba70d7
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/conditional.rst
@@ -0,0 +1,207 @@
+Conditional
+===========
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`COALESCE <coalesce>`
+     - Returns the first non-null value in the provided values/columns.
+   * - :ref:`GREATEST <greatest>`
+     - Returns the greatest value in the list of expressions.
+   * - :ref:`IF <if>`
+     - Returns expr1 if the boolean condition provided as the first parameter evaluates to true, and expr2 otherwise.
+   * - :ref:`IFNULL <ifnull>`
+     - If an expression value is NULL, return an alternative value.
+   * - :ref:`LEAST <least>`
+     - Returns the smallest value in the list of expressions.
+   * - :ref:`NULLIF <nullif>`
+     - Returns NULL if two expressions are equal, otherwise returns the first.
+
+.. _coalesce:
+
+COALESCE
+--------
+Returns the first non-null value in the provided values/columns.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [1, None, 3, None],
+        "bar": [1, 2, None, 4],
+      }
+    )
+    df.sql("""
+      SELECT foo, bar, COALESCE(foo, bar) AS baz FROM self
+    """)
+    # shape: (4, 3)
+    # ┌──────┬──────┬─────┐
+    # │ foo  ┆ bar  ┆ baz │
+    # │ ---  ┆ ---  ┆ --- │
+    # │ i64  ┆ i64  ┆ i64 │
+    # ╞══════╪══════╪═════╡
+    # │ 1    ┆ 1    ┆ 1   │
+    # │ null ┆ 2    ┆ 2   │
+    # │ 3    ┆ null ┆ 3   │
+    # │ null ┆ 4    ┆ 4   │
+    # └──────┴──────┴─────┘
+
+.. _greatest:
+
+GREATEST
+--------
+Returns the greatest value in the list of expressions.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [100, 200, 300, 400], 
+        "bar": [20, 10, 30, 40]
+      }
+    )
+    df.sql("""
+      SELECT GREATEST(foo, bar) AS baz FROM self
+    """)
+    # shape: (4, 1)
+    # ┌─────┐
+    # │ baz │
+    # │ --- │
+    # │ i64 │
+    # ╞═════╡
+    # │ 100 │
+    # │ 200 │
+    # │ 300 │
+    # │ 400 │
+    # └─────┘
+
+.. _if:
+
+IF
+--
+Returns expr1 if the boolean condition provided as the first parameter evaluates to true, and expr2 otherwise.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [100, 200, 300, 400],
+        "bar": [10, 20, 30, 40]
+      }
+    )
+    df.sql("""
+      SELECT IF(foo < 250, 111, 999) AS baz FROM self
+    """)
+    # shape: (4, 1)
+    # ┌─────┐
+    # │ baz │
+    # │ --- │
+    # │ i32 │
+    # ╞═════╡
+    # │ 111 │
+    # │ 111 │
+    # │ 999 │
+    # │ 999 │
+    # └─────┘
+
+.. _ifnull:
+
+IFNULL
+------
+If an expression value is NULL, return an alternative value.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["a", None, None, "d"],
+        "bar": [1, 2, 3, 4],
+      }
+    )
+    df.sql("""
+      SELECT IFNULL(foo, 'n/a') AS baz FROM self
+    """)
+    # shape: (4, 1)
+    # ┌─────┐
+    # │ baz │
+    # │ --- │
+    # │ str │
+    # ╞═════╡
+    # │ a   │
+    # │ n/a │
+    # │ n/a │
+    # │ d   │
+    # └─────┘
+
+.. _least:
+
+LEAST
+-----
+Returns the smallest value in the list of expressions.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [100, 200, 300, 400],
+        "bar": [20, 10, 30, 40]
+      }
+    )
+    df.sql("""
+      SELECT LEAST(foo, bar) AS baz FROM self
+    """)
+    # shape: (4, 1)
+    # ┌─────┐
+    # │ baz │
+    # │ --- │
+    # │ i64 │
+    # ╞═════╡
+    # │ 20  │
+    # │ 10  │
+    # │ 30  │
+    # │ 40  │
+    # └─────┘
+
+.. _nullif:
+
+NULLIF
+------
+Returns NULL if two expressions are equal, otherwise returns the first.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": [100, 200, 300, 400],
+        "bar": [20, 10, 30, 40]
+      }
+    )
+    df.sql("""
+      SELECT NULLIF(foo, bar) AS baz FROM self
+    """)
+    # shape: (4, 1)
+    # ┌─────┐
+    # │ baz │
+    # │ --- │
+    # │ i64 │
+    # ╞═════╡
+    # │ 100 │
+    # │ 200 │
+    # │ 300 │
+    # │ 400 │
+    # └─────┘
diff --git a/py-polars/docs/source/reference/sql/functions/index.rst b/py-polars/docs/source/reference/sql/functions/index.rst
new file mode 100644
index 000000000000..607e720956a3
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/index.rst
@@ -0,0 +1,87 @@
+=============
+SQL Functions
+=============
+
+
+.. raw:: html
+
+    <style>
+      div.sd-card-body.docutils li.toctree-l1 > :first-child {display: none;}
+    </style>
+
+
+.. grid::
+
+    .. grid-item-card::
+
+        **Aggregate**
+        ^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           aggregate
+
+    .. grid-item-card::
+
+        **Array**
+        ^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           array
+
+    .. grid-item-card::
+
+        **Conditional**
+        ^^^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           conditional
+
+    .. grid-item-card::
+
+        **Mathematical**
+        ^^^^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           math
+
+.. grid::
+
+    .. grid-item-card::
+
+        **String**
+        ^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           string
+
+    .. grid-item-card::
+
+        **Temporal**
+        ^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           temporal
+
+    .. grid-item-card::
+
+        **Trigonometry**
+        ^^^^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           trigonometry
+
+    .. grid-item-card::
diff --git a/py-polars/docs/source/reference/sql/functions/math.rst b/py-polars/docs/source/reference/sql/functions/math.rst
new file mode 100644
index 000000000000..366b2172acb5
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/math.rst
@@ -0,0 +1,448 @@
+Math
+====
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`ABS <abs>`
+     - Returns the absolute value of the input column.
+   * - :ref:`CBRT <cbrt>`
+     - Returns the cube root (∛) of a number.
+   * - :ref:`CEIL <ceil>`
+     - Returns the nearest integer closest from zero.
+   * - :ref:`EXP <exp>`
+     - Computes the exponential of the given value.
+   * - :ref:`FLOOR <floor_function>`
+     - Returns the nearest integer away from zero.
+   * - :ref:`LN <ln>`
+     - Computes the natural logarithm of the given value.
+   * - :ref:`LOG <log>`
+     - Computes the `base` logarithm of the given value.
+   * - :ref:`LOG2 <log2>`
+     - Computes the logarithm of the given value in base 2.
+   * - :ref:`LOG10 <log10>`
+     - Computes the logarithm of the given value in base 10.
+   * - :ref:`LOG1P <log1p>`
+     - Computes the natural logarithm of "given value plus one".
+   * - :ref:`MOD <mod>`
+     - Returns the remainder of a numeric expression divided by another numeric expression.
+   * - :ref:`PI <pi>`
+     - Returns a (very good) approximation of 𝜋.
+   * - :ref:`POW <pow>`
+     - Returns the value to the power of the given exponent.
+   * - :ref:`ROUND <round>`
+     - Round a number to `x` decimals (default: 0) away from zero.
+   * - :ref:`SIGN <sign>`
+     - Returns the sign of the argument as -1, 0, or +1.
+   * - :ref:`SQRT <sqrt>`
+     - Returns the square root (√) of a number.
+
+.. _abs:
+
+ABS
+---
+Returns the absolute value of the input column.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [-1.0, 0.0, 1.0, -2.0]})
+    df.sql("""
+      SELECT ABS(a) FROM self
+    """)
+    # shape: (4, 1)
+    # ┌─────┐
+    # │ a   │
+    # │ --- │
+    # │ f64 │
+    # ╞═════╡
+    # │ 1.0 │
+    # │ 0.0 │
+    # │ 1.0 │
+    # │ 2.0 │
+    # └─────┘
+
+.. _cbrt:
+
+CBRT
+----
+Returns the cube root (∛) of a number.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [1.0, 2.0, 4.0]})
+    df.sql("""
+      SELECT CBRT(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌──────────┐
+    # │ a        │
+    # │ ---      │
+    # │ f64      │
+    # ╞══════════╡
+    # │ 1.0      │
+    # │ 1.259921 │
+    # │ 1.587401 │
+    # └──────────┘
+
+.. _ceil:
+
+CEIL 
+----
+Returns the nearest integer closest from zero.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [0.1, 2.8, 4.30]})
+    df.sql("""
+      SELECT CEIL(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌─────┐
+    # │ a   │
+    # │ --- │
+    # │ f64 │
+    # ╞═════╡
+    # │ 1.0 │
+    # │ 3.0 │
+    # │ 5.0 │
+    # └─────┘
+
+.. _exp:
+
+EXP 
+---
+Computes the exponential of the given value.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [1, 2, 4]})
+    df.sql("""
+      SELECT EXP(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌──────────┐
+    # │ a        │
+    # │ ---      │
+    # │ f64      │
+    # ╞══════════╡
+    # │ 2.718282 │
+    # │ 7.389056 │
+    # │ 54.59815 │
+    # └──────────┘
+
+.. _floor_function:
+
+FLOOR 
+-----
+Returns the nearest integer away from zero.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [0.1, 2.8, 4.30]})
+    df.sql("""
+      SELECT FLOOR(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌─────┐
+    # │ a   │
+    # │ --- │
+    # │ f64 │
+    # ╞═════╡
+    # │ 0.0 │
+    # │ 2.0 │
+    # │ 4.0 │
+    # └─────┘
+
+.. _ln:
+
+LN
+--
+Computes the natural logarithm of the given value.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [1, 2, 4]})
+    df.sql("""
+      SELECT LN(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌──────────┐
+    # │ a        │
+    # │ ---      │
+    # │ f64      │
+    # ╞══════════╡
+    # │ 0.0      │
+    # │ 0.693147 │
+    # │ 1.386294 │
+    # └──────────┘
+
+.. _log:
+
+LOG
+---
+Computes the `base` logarithm of the given value.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [1, 2, 4]})
+    df.sql("""
+      SELECT LOG(a, 10) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌─────────┐
+    # │ a       │
+    # │ ---     │
+    # │ f64     │
+    # ╞═════════╡
+    # │ 0.0     │
+    # │ 0.30103 │
+    # │ 0.60206 │
+    # └─────────┘
+
+.. _log2:
+
+LOG2 
+----
+Computes the logarithm of the given value in base 2.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [1, 2, 4]})
+    df.sql("""
+      SELECT LOG2(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌─────┐
+    # │ a   │
+    # │ --- │
+    # │ f64 │
+    # ╞═════╡
+    # │ 0.0 │
+    # │ 1.0 │
+    # │ 2.0 │
+    # └─────┘
+
+.. _log10:
+
+LOG10
+-----
+Computes the logarithm of the given value in base 10.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [1, 2, 4]})
+    df.sql("""
+      SELECT LOG10(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌─────────┐
+    # │ a       │
+    # │ ---     │
+    # │ f64     │
+    # ╞═════════╡
+    # │ 0.0     │
+    # │ 0.30103 │
+    # │ 0.60206 │
+    # └─────────┘
+
+.. _log1p:
+
+LOG1P
+-----
+Computes the natural logarithm of "given value plus one".
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"a": [1, 2, 4]})
+    df.sql("""
+      SELECT LOG1P(a) FROM self
+    """)
+    # shape: (3, 1)
+    # ┌──────────┐
+    # │ a        │
+    # │ ---      │
+    # │ f64      │
+    # ╞══════════╡
+    # │ 0.693147 │
+    # │ 1.098612 │
+    # │ 1.609438 │
+    # └──────────┘
+
+.. _mod:
+
+MOD
+---
+Returns the remainder of a numeric expression divided by another numeric expression.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"x": [0, 1, 2, 3, 4]})
+    df.sql("""
+      SELECT MOD(x, 2) FROM self
+    """)
+    # shape: (5, 1)
+    # ┌─────┐
+    # │ x   │
+    # │ --- │
+    # │ i64 │
+    # ╞═════╡
+    # │ 0   │
+    # │ 1   │
+    # │ 0   │
+    # │ 1   │
+    # │ 0   │
+    # └─────┘
+
+.. _pi:
+
+PI
+--
+Returns a (good) approximation of 𝜋.
+
+**Example:**
+
+.. code-block:: python
+
+    df.sql("""
+      SELECT PI() AS pi FROM self
+    """)
+    # shape: (1, 1)
+    # ┌──────────┐
+    # │ pi       │
+    # │ ---      │
+    # │ f64      │
+    # ╞══════════╡
+    # │ 3.141593 │
+    # └──────────┘
+
+.. _pow:
+
+POW
+---
+Returns the value to the power of the given exponent.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"x": [0, 1, 2, 3, 4]})
+    df.sql("""
+      SELECT POW(x, 2) FROM self
+    """)
+    # shape: (5, 1)
+    # ┌─────┐
+    # │ x   │
+    # │ --- │
+    # │ i64 │
+    # ╞═════╡
+    # │ 0   │
+    # │ 1   │
+    # │ 4   │
+    # │ 9   │
+    # │ 16  │
+    # └─────┘
+
+.. _round:
+
+ROUND
+-----
+Round a number to `x` decimals (default: 0) away from zero.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"x": [0.4, 1.8, 2.2, 3.6, 4.1]})
+    df.sql("""
+      SELECT ROUND(x) FROM self
+    """)
+    # shape: (5, 1)
+    # ┌─────┐
+    # │ x   │
+    # │ --- │
+    # │ f64 │
+    # ╞═════╡
+    # │ 0.0 │
+    # │ 2.0 │
+    # │ 2.0 │
+    # │ 4.0 │
+    # │ 4.0 │
+    # └─────┘
+
+.. _sign:
+
+SIGN
+----
+Returns the sign of the argument as -1, 0, or +1.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"x": [0.4, -1, 0, -2, 4]})
+    df.sql("""
+      SELECT SIGN(x) FROM self
+    """)
+    # shape: (5, 1)
+    # ┌─────┐
+    # │ x   │
+    # │ --- │
+    # │ i64 │
+    # ╞═════╡
+    # │ 1   │
+    # │ -1  │
+    # │ 0   │
+    # │ -1  │
+    # │ 1   │
+    # └─────┘
+
+.. _sqrt:
+
+SQRT
+----
+Returns the square root (√) of a number.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"x": [2, 4, 49, 64]})
+    df.sql("""
+      SELECT SQRT(x) FROM self
+    """)
+    # shape: (4, 1)
+    # ┌──────────┐
+    # │ x        │
+    # │ ---      │
+    # │ f64      │
+    # ╞══════════╡
+    # │ 1.414214 │
+    # │ 2.0      │
+    # │ 7.0      │
+    # │ 8.0      │
+    # └──────────┘
diff --git a/py-polars/docs/source/reference/sql/functions/string.rst b/py-polars/docs/source/reference/sql/functions/string.rst
new file mode 100644
index 000000000000..97e072ee6418
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/string.rst
@@ -0,0 +1,580 @@
+String
+======
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - :ref:`BIT_LENGTH <bit_length>`
+     - Returns the length of the input string in bits.
+   * - :ref:`CONCAT <concat>`
+     - Returns all input expressions concatenated together as a string.
+   * - :ref:`CONCAT_WS <concat_ws>`
+     - Returns all input expressions concatenated together (and interleaved with a separator) as a string.
+   * - :ref:`ENDS_WITH <ends_with>`
+     - Returns True if the value ends with the second argument.
+   * - :ref:`INITCAP <initcap>`
+     - Returns the value with the first letter capitalized.
+   * - :ref:`LEFT <left>`
+     - Returns the first (leftmost) `n` characters.
+   * - :ref:`LENGTH <length>`
+     - Returns the character length of the string.
+   * - :ref:`LOWER <lower>`
+     - Returns a lowercased column.
+   * - :ref:`LTRIM <ltrim>`
+     - Strips whitespaces from the left.
+   * - :ref:`OCTET_LENGTH <octet_length>`
+     - Returns the length of a given string in bytes.
+   * - :ref:`REGEXP_LIKE <regexp_like>`
+     - Returns True if `pattern` matches the value (optional: `flags`).
+   * - :ref:`REPLACE <replace>`
+     - Replaces a given substring with another string.
+   * - :ref:`REVERSE <reverse>`
+     - Returns the reversed string.
+   * - :ref:`RIGHT <right>`
+     - Returns the last (rightmost) `n` characters.
+   * - :ref:`RTRIM <rtrim>`
+     - Strips whitespaces from the right.
+   * - :ref:`STARTS_WITH <starts_with>`
+     - Returns True if the value starts with the second argument.
+   * - :ref:`STRPOST <strpos>`
+     - Returns the index of the given substring in the target string.
+   * - :ref:`SUBSTRING <substring>`
+     - Returns a portion of the data (first character = 0) in the range [start, start + length].
+   * - :ref:`UPPER <upper>`
+     - Returns an uppercased column.
+
+.. _bit_length:
+
+BIT_LENGTH
+----------
+Returns the length of the input string in bits.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["a", "bb", "ccc", "dddd"]})
+    df.sql("""
+      SELECT foo, BIT_LENGTH(foo) AS n_bits FROM self
+    """)
+    # shape: (4, 2)
+    # ┌──────┬────────┐
+    # │ foo  ┆ n_bits │
+    # │ ---  ┆ ---    │
+    # │ str  ┆ u32    │
+    # ╞══════╪════════╡
+    # │ a    ┆ 8      │
+    # │ bb   ┆ 16     │
+    # │ ccc  ┆ 24     │
+    # │ dddd ┆ 32     │
+    # └──────┴────────┘
+
+.. _concat:
+
+CONCAT
+------
+Returns all input expressions concatenated together as a string.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["aa", "b", "c", "dd"],
+        "bar": ["zz", "yy", "xx", "ww"],
+      }
+    )
+    df.sql("""
+      SELECT CONCAT(foo, bar) AS foobar FROM self
+    """)
+    # shape: (4, 1)
+    # ┌────────┐
+    # │ foobar │
+    # │ ---    │
+    # │ str    │
+    # ╞════════╡
+    # │ aazz   │
+    # │ byy    │
+    # │ cxx    │
+    # │ ddww   │
+    # └────────┘
+
+.. _concat_ws:
+
+CONCAT_WS
+---------
+Returns all input expressions concatenated together (and interleaved with a separator) as a string.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["aa", "b", "c", "dd"],
+        "bar": ["zz", "yy", "xx", "ww"],
+      }
+    )
+    df.sql("""
+      SELECT CONCAT_WS(':', foo, bar) AS foobar FROM self
+    """)
+    # shape: (4, 1)
+    # ┌────────┐
+    # │ foobar │
+    # │ ---    │
+    # │ str    │
+    # ╞════════╡
+    # │ aa:zz  │
+    # │ b:yy   │
+    # │ c:xx   │
+    # │ dd:ww  │
+    # └────────┘
+
+.. _ends_with:
+
+ENDS_WITH
+---------
+Returns True if the value ends with the second argument.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["aa", "bb", "cc", "dd"],
+        "bar": ["zz", "yy", "xx", "ww"],
+      }
+    )
+    df.sql("""
+      SELECT foo, ENDS_WITH(foo, 'a') AS ends_a FROM self
+    """)
+    # shape: (4, 2)
+    # ┌─────┬────────┐
+    # │ foo ┆ ends_a │
+    # │ --- ┆ ---    │
+    # │ str ┆ bool   │
+    # ╞═════╪════════╡
+    # │ aa  ┆ true   │
+    # │ bb  ┆ false  │
+    # │ cc  ┆ false  │
+    # │ dd  ┆ false  │
+    # └─────┴────────┘
+
+.. _initcap:
+
+INITCAP
+-------
+Returns the value with the first letter capitalized.
+
+**Example:**
+
+.. code-block:: python
+  
+    df = pl.DataFrame({"bar": ["zz", "yy", "xx", "ww"]})
+    df.sql("""
+      SELECT bar, INITCAP(bar) AS baz FROM self
+    """)
+    # shape: (4, 2)
+    # ┌─────┬─────┐
+    # │ bar ┆ baz │
+    # │ --- ┆ --- │
+    # │ str ┆ str │
+    # ╞═════╪═════╡
+    # │ zz  ┆ Zz  │
+    # │ yy  ┆ Yy  │
+    # │ xx  ┆ Xx  │
+    # │ ww  ┆ Ww  │
+    # └─────┴─────┘
+
+.. _left:
+
+LEFT
+----
+Returns the first (leftmost) `n` characters.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "foo": ["abcd", "efgh", "ijkl", "mnop"],
+        "bar": ["zz", "yy", "xx", "ww"],
+      }
+    )
+    df.sql("""
+      SELECT
+        LEFT(foo, 1) AS foo1,
+        LEFT(bar, 2) AS bar2
+      FROM self
+    """)
+
+    # shape: (4, 2)
+    # ┌──────┬──────┐
+    # │ foo1 ┆ bar2 │
+    # │ ---  ┆ ---  │
+    # │ str  ┆ str  │
+    # ╞══════╪══════╡
+    # │ a    ┆ zz   │
+    # │ e    ┆ yy   │
+    # │ i    ┆ xx   │
+    # │ m    ┆ ww   │
+    # └──────┴──────┘
+
+.. _length:
+
+LENGTH
+------
+Returns the character length of the string.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "iso_lang":["de", "ru", "es"],
+        "color": ["weiß", "синий", "amarillo"],
+      }
+    )
+    df.sql("""
+      SELECT
+        iso_lang,
+        color,
+        LENGTH(color) AS n_chars,
+        OCTET_LENGTH(color) AS n_bytes
+      FROM self
+    """)
+    # shape: (3, 4)
+    # ┌──────────┬──────────┬─────────┬─────────┐
+    # │ iso_lang ┆ color    ┆ n_chars ┆ n_bytes │
+    # │ ---      ┆ ---      ┆ ---     ┆ ---     │
+    # │ str      ┆ str      ┆ u32     ┆ u32     │
+    # ╞══════════╪══════════╪═════════╪═════════╡
+    # │ de       ┆ weiß     ┆ 4       ┆ 5       │
+    # │ ru       ┆ синий    ┆ 5       ┆ 10      │
+    # │ es       ┆ amarillo ┆ 8       ┆ 8       │
+    # └──────────┴──────────┴─────────┴─────────┘
+
+.. _lower:
+
+LOWER
+-----
+Returns a lowercased column.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["AA", "BB", "CC", "DD"]})
+    df.sql("""
+      SELECT foo, LOWER(foo) AS foo_lower FROM self
+    """)
+    # shape: (4, 2)
+    # ┌─────┬───────────┐
+    # │ foo ┆ foo_lower │
+    # │ --- ┆ ---       │
+    # │ str ┆ str       │
+    # ╞═════╪═══════════╡
+    # │ AA  ┆ aa        │
+    # │ BB  ┆ bb        │
+    # │ CC  ┆ cc        │
+    # │ DD  ┆ dd        │
+    # └─────┴───────────┘
+
+.. _ltrim:
+
+LTRIM
+-----
+Strips whitespaces from the left.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["   AA", " BB", "CC", "  DD"]})
+    df.sql("""
+      SELECT foo, LTRIM(foo) AS trimmed FROM self
+    """)
+    # shape: (4, 2)
+    # ┌───────┬─────────┐
+    # │ foo   ┆ trimmed │
+    # │ ---   ┆ ---     │
+    # │ str   ┆ str     │
+    # ╞═══════╪═════════╡
+    # │    AA ┆ AA      │
+    # │  BB   ┆ BB      │
+    # │ CC    ┆ CC      │
+    # │   DD  ┆ DD      │
+    # └───────┴─────────┘
+
+.. _octet_length:
+
+OCTET_LENGTH
+------------
+Returns the length of a given string in bytes.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "iso_lang":["de", "ru", "es"],
+        "color": ["weiß", "синий", "amarillo"],
+      }
+    )
+    df.sql("""
+      SELECT
+        iso_lang,
+        color,
+        OCTET_LENGTH(color) AS n_bytes,
+        LENGTH(color) AS n_chars
+      FROM self
+    """)
+    # shape: (3, 4)
+    # ┌──────────┬──────────┬─────────┬─────────┐
+    # │ iso_lang ┆ color    ┆ n_bytes ┆ n_chars │
+    # │ ---      ┆ ---      ┆ ---     ┆ ---     │
+    # │ str      ┆ str      ┆ u32     ┆ u32     │
+    # ╞══════════╪══════════╪═════════╪═════════╡
+    # │ de       ┆ weiß     ┆ 5       ┆ 4       │
+    # │ ru       ┆ синий    ┆ 10      ┆ 5       │
+    # │ es       ┆ amarillo ┆ 8       ┆ 8       │
+    # └──────────┴──────────┴─────────┴─────────┘
+
+.. _regexp_like:
+
+REGEXP_LIKE
+-----------
+Returns True if `pattern` matches the value (optional: `flags`).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["abc123", "4ab4a", "abc456", "321cba"]})
+    df.sql(r"""
+      SELECT foo, REGEXP_LIKE(foo, '\d$') AS ends_in_digit FROM self
+    """)
+    # shape: (4, 2)
+    # ┌────────┬───────────────┐
+    # │ foo    ┆ ends_in_digit │
+    # │ ---    ┆ ---           │
+    # │ str    ┆ bool          │
+    # ╞════════╪═══════════════╡
+    # │ abc123 ┆ true          │
+    # │ 4ab4a  ┆ false         │
+    # │ abc456 ┆ true          │
+    # │ 321cba ┆ false         │
+    # └────────┴───────────────┘
+
+.. _replace:
+
+REPLACE
+-------
+Replaces a given substring with another string.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["abc123", "11aabb", "bcbc45"]})
+    df.sql("""
+      SELECT foo, REPLACE(foo, 'b', '?') AS bar FROM self
+    """)
+    # shape: (3, 2)
+    # ┌────────┬────────┐
+    # │ foo    ┆ bar    │
+    # │ ---    ┆ ---    │
+    # │ str    ┆ str    │
+    # ╞════════╪════════╡
+    # │ abc123 ┆ a?c123 │
+    # │ 11aabb ┆ 11aa?? │
+    # │ bcbc45 ┆ ?c?c45 │
+    # └────────┴────────┘
+
+.. _reverse:
+
+REVERSE
+-------
+Returns the reversed string.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
+    df.sql("""
+      SELECT foo, REVERSE(foo) AS oof FROM self
+    """)
+    # shape: (4, 2)
+    # ┌────────┬────────┐
+    # │ foo    ┆ oof    │
+    # │ ---    ┆ ---    │
+    # │ str    ┆ str    │
+    # ╞════════╪════════╡
+    # │ apple  ┆ elppa  │
+    # │ banana ┆ ananab │
+    # │ orange ┆ egnaro │
+    # │ grape  ┆ eparg  │
+    # └────────┴────────┘
+
+.. _right:
+
+RIGHT
+-----
+Returns the last (rightmost) `n` characters.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["ab", "cde", "fghi", "jklmn"]})
+    df.sql("""
+      SELECT foo, RIGHT(foo, 2) AS bar FROM self
+    """)
+    # shape: (4, 2)
+    # ┌───────┬─────┐
+    # │ foo   ┆ bar │
+    # │ ---   ┆ --- │
+    # │ str   ┆ str │
+    # ╞═══════╪═════╡
+    # │ ab    ┆ ab  │
+    # │ cde   ┆ de  │
+    # │ fghi  ┆ hi  │
+    # │ jklmn ┆ mn  │
+    # └───────┴─────┘
+
+.. _rtrim:
+
+RTRIM
+-----
+Strips whitespaces from the right.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"bar": ["zz    ", "yy  ", "xx ", "ww   "]})
+    df.sql("""
+      SELECT bar, RTRIM(bar) AS baz FROM self
+    """)
+    # shape: (4, 2)
+    # ┌────────┬─────┐
+    # │ bar    ┆ baz │
+    # │ ---    ┆ --- │
+    # │ str    ┆ str │
+    # ╞════════╪═════╡
+    # │ zz     ┆ zz  │
+    # │ yy     ┆ yy  │
+    # │ xx     ┆ xx  │
+    # │ ww     ┆ ww  │
+    # └────────┴─────┘
+
+.. _starts_with:
+
+STARTS_WITH
+-----------
+Returns True if the value starts with the second argument.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["apple", "banana", "avocado", "grape"]})
+    df.sql("""
+      SELECT foo, STARTS_WITH(foo, 'a') AS starts_a FROM self
+    """)
+    # shape: (4, 2)
+    # ┌─────────┬──────────┐
+    # │ foo     ┆ starts_a │
+    # │ ---     ┆ ---      │
+    # │ str     ┆ bool     │
+    # ╞═════════╪══════════╡
+    # │ apple   ┆ true     │
+    # │ banana  ┆ false    │
+    # │ avocado ┆ true     │
+    # │ grape   ┆ false    │
+    # └─────────┴──────────┘
+
+.. _strpos:
+
+STRPOS
+------
+Returns the index of the given substring in the target string.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
+    df.sql("""
+      SELECT foo, STRPOS(foo, 'a') AS pos_a FROM self
+    """)
+    # shape: (4, 2)
+    # ┌────────┬───────┐
+    # │ foo    ┆ pos_a │
+    # │ ---    ┆ ---   │
+    # │ str    ┆ u32   │
+    # ╞════════╪═══════╡
+    # │ apple  ┆ 1     │
+    # │ banana ┆ 2     │
+    # │ orange ┆ 3     │
+    # │ grape  ┆ 3     │
+    # └────────┴───────┘
+
+.. _substring:
+
+SUBSTRING
+---------
+Returns a slice of the string data (1-indexed) in the range [start, start + length].
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
+    df.sql("""
+      SELECT foo, SUBSTR(foo, 3, 4) AS foo_3_4 FROM self
+    """)
+    # shape: (4, 2)
+    # ┌────────┬─────────┐
+    # │ foo    ┆ foo_3_4 │
+    # │ ---    ┆ ---     │
+    # │ str    ┆ str     │
+    # ╞════════╪═════════╡
+    # │ apple  ┆ ple     │
+    # │ banana ┆ nana    │
+    # │ orange ┆ ange    │
+    # │ grape  ┆ ape     │
+    # └────────┴─────────┘
+
+.. _upper:
+
+UPPER
+-----
+Returns an uppercased column.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
+    df.sql("""
+      SELECT foo, UPPER(foo) AS foo_upper FROM self
+    """)
+    # shape: (4, 2)
+    # ┌────────┬───────────┐
+    # │ foo    ┆ foo_upper │
+    # │ ---    ┆ ---       │
+    # │ str    ┆ str       │
+    # ╞════════╪═══════════╡
+    # │ apple  ┆ APPLE     │
+    # │ banana ┆ BANANA    │
+    # │ orange ┆ ORANGE    │
+    # │ grape  ┆ GRAPE     │
+    # └────────┴───────────┘
diff --git a/py-polars/docs/source/reference/sql/functions/temporal.rst b/py-polars/docs/source/reference/sql/functions/temporal.rst
new file mode 100644
index 000000000000..11a00c1e2412
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/temporal.rst
@@ -0,0 +1,158 @@
+Temporal
+========
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`DATE <date>`
+     - Converts a formatted string date to an actual Date type.
+   * - :ref:`DATE_PART <date_part>`
+     - Extracts a part of a date (or datetime) such as 'year', 'month', etc.
+   * - :ref:`EXTRACT <extract>`
+     - Offers the same functionality as `DATE_PART` with slightly different syntax.
+
+.. _date:
+
+DATE
+----
+Converts a formatted string date to an actual Date type; ISO-8601 format is assumed
+unless a strftime-compatible formatting string is provided as the second parameter.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame({"str_date": ["1969.10.30", "2024.07.05", "2077.02.28"]})
+    df.sql("""
+      SELECT str_date, DATE(str_date, '%Y.%m.%d') AS date FROM self
+    """)
+    # shape: (3, 2)
+    # ┌────────────┬────────────┐
+    # │ str_date   ┆ date       │
+    # │ ---        ┆ ---        │
+    # │ str        ┆ date       │
+    # ╞════════════╪════════════╡
+    # │ 1969.10.30 ┆ 1969-10-30 │
+    # │ 2024.07.05 ┆ 2024-07-05 │
+    # │ 2077.02.28 ┆ 2077-02-28 │
+    # └────────────┴────────────┘
+
+.. _date_part:
+
+DATE_PART
+---------
+Extracts a part of a date (or datetime) such as 'year', 'month', etc.
+
+**Supported parts/fields:**
+    - "day"
+    - "dayofweek" | "dow"
+    - "dayofyear" | "doy"
+    - "decade"
+    - "epoch"
+    - "hour"
+    - "isodow"
+    - "isoweek" | "week"
+    - "isoyear"
+    - "microsecond(s)"
+    - "millisecond(s)"
+    - "nanosecond(s)"
+    - "minute"
+    - "month"
+    - "quarter"
+    - "second"
+    - "time"
+    - "year"
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+          "dt": [
+              date(1969, 12, 31),
+              date(2026, 8, 22),
+              date(2077, 2, 10),
+          ]
+      }
+    )
+    df.sql("""
+      SELECT
+        dt,
+        DATE_PART(dt, 'year') AS year,
+        DATE_PART(dt, 'month') AS month,
+        DATE_PART(dt, 'day') AS day
+      FROM self
+    """)
+
+    # shape: (3, 4)
+    # ┌────────────┬──────┬───────┬─────┐
+    # │ dt         ┆ year ┆ month ┆ day │
+    # │ ---        ┆ ---  ┆ ---   ┆ --- │
+    # │ date       ┆ i32  ┆ i8    ┆ i8  │
+    # ╞════════════╪══════╪═══════╪═════╡
+    # │ 1969-12-31 ┆ 1969 ┆ 12    ┆ 31  │
+    # │ 2026-08-22 ┆ 2026 ┆ 8     ┆ 22  │
+    # │ 2077-02-10 ┆ 2077 ┆ 2     ┆ 10  │
+    # └────────────┴──────┴───────┴─────┘
+
+.. _extract:
+
+EXTRACT
+-------
+Extracts a part of a date (or datetime) such as 'year', 'month', etc.
+
+**Supported parts/fields:**
+    - "day"
+    - "dayofweek" | "dow"
+    - "dayofyear" | "doy"
+    - "decade"
+    - "epoch"
+    - "hour"
+    - "isodow"
+    - "isoweek" | "week"
+    - "isoyear"
+    - "microsecond(s)"
+    - "millisecond(s)"
+    - "nanosecond(s)"
+    - "minute"
+    - "month"
+    - "quarter"
+    - "second"
+    - "time"
+    - "year"
+
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+          "dt": [
+              date(1969, 12, 31),
+              date(2026, 8, 22),
+              date(2077, 2, 10),
+          ]
+      }
+    )
+    df.sql("""
+      SELECT
+        dt,
+        EXTRACT(decade FROM dt) AS decade,
+        EXTRACT(year FROM dt) AS year,
+        EXTRACT(quarter FROM dt) AS quarter,
+      FROM self
+    """)
+
+    # shape: (3, 4)
+    # ┌────────────┬────────┬──────┬─────────┐
+    # │ dt         ┆ decade ┆ year ┆ quarter │
+    # │ ---        ┆ ---    ┆ ---  ┆ ---     │
+    # │ date       ┆ i32    ┆ i32  ┆ i8      │
+    # ╞════════════╪════════╪══════╪═════════╡
+    # │ 1969-12-31 ┆ 196    ┆ 1969 ┆ 4       │
+    # │ 2026-08-22 ┆ 202    ┆ 2026 ┆ 3       │
+    # │ 2077-02-10 ┆ 207    ┆ 2077 ┆ 1       │
+    # └────────────┴────────┴──────┴─────────┘
diff --git a/py-polars/docs/source/reference/sql/functions/trigonometry.rst b/py-polars/docs/source/reference/sql/functions/trigonometry.rst
new file mode 100644
index 000000000000..c502b48f7903
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/functions/trigonometry.rst
@@ -0,0 +1,580 @@
+Trigonometry
+============
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - :ref:`ACOS <acos>`
+     - Compute inverse cosine of the input column (in radians).
+   * - :ref:`ACOSD <acosd>`
+     - Compute inverse cosine of the input column (in degrees).
+   * - :ref:`ASIN <asin>`
+     - Compute inverse sine of the input column (in radians).
+   * - :ref:`ASIND <asind>`
+     - Compute inverse sine of the input column (in degrees).
+   * - :ref:`ATAN <atan>`
+     - Compute inverse tangent of the input column (in radians).
+   * - :ref:`ATAND <atand>`
+     - Compute inverse tangent of the input column (in degrees).
+   * - :ref:`ATAN2 <atan2>`
+     - Compute the inverse tangent of column_2/column_1 (in radians).
+   * - :ref:`ATAN2D <atan2d>`
+     - Compute the inverse tangent of column_2/column_1 (in degrees).
+   * - :ref:`COT <cot>`
+     - Compute the cotangent of the input column (in radians).
+   * - :ref:`COTD <cotd>`
+     - Compute cotangent of the input column (in degrees).
+   * - :ref:`COS <cos>`
+     - Compute the cosine of the input column (in radians).
+   * - :ref:`COSD <cosd>`
+     - Compute the cosine of the input column (in degrees).
+   * - :ref:`DEGREES <degrees>`
+     - Convert between radians and degrees.
+   * - :ref:`RADIANS <radians>`
+     - Convert between degrees and radians.
+   * - :ref:`SIN <sin>`
+     - Compute the sine of the input column (in radians).
+   * - :ref:`SIND <sind>`
+     - Compute the sine of the input column (in degrees).
+   * - :ref:`TAN <tan>`
+     - Compute the tangent of the input column (in radians).
+   * - :ref:`TAND <tand>`
+     - Compute the tangent of the input column (in degrees).
+
+.. _acos:
+
+ACOS
+----
+Compute inverse cosine of the input column (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+      }
+    )
+
+    df.sql("SELECT ACOS(a) AS ACOS FROM self")
+
+    # shape: (4, 1)
+    # ┌──────────┐
+    # │ ACOS     │
+    # │ ---      │
+    # │ f64      │
+    # ╞══════════╡
+    # │ 3.141593 │
+    # │ 2.094395 │
+    # │ 1.047198 │
+    # │ 0.0      │
+    # └──────────┘
+
+.. _acosd:
+
+ACOSD
+-----
+Compute inverse cosine of the input column (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+      }
+    )
+
+    df.sql("SELECT ACOSD(a) AS ACOSD FROM self")
+    # shape: (4, 1)
+    # ┌───────┐
+    # │ ACOSD │
+    # │ ---   │
+    # │ f64   │
+    # ╞═══════╡
+    # │ 180.0 │
+    # │ 120.0 │
+    # │ 60.0  │
+    # │ 0.0   │
+    # └───────┘
+
+.. _asin:
+
+ASIN
+----
+Compute inverse sine of the input column (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+      }
+    )
+
+    df.sql("SELECT ASIN(a) AS ASIN FROM self")
+    # shape: (4, 1)
+    # ┌───────────┐
+    # │ ASIN      │
+    # │ ---       │
+    # │ f64       │
+    # ╞═══════════╡
+    # │ -1.570796 │
+    # │ -0.523599 │
+    # │ 0.523599  │
+    # │ 1.570796  │
+    # └───────────┘
+
+.. _asind:
+
+ASIND
+-----
+Compute inverse sine of the input column (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+      }
+    )
+
+    df.sql("SELECT ASIND(a) AS ASIND FROM self")
+    # shape: (4, 1)
+    # ┌───────┐
+    # │ ASIND │
+    # │ ---   │
+    # │ f64   │
+    # ╞═══════╡
+    # │ -90.0 │
+    # │ -30.0 │
+    # │ 30.0  │
+    # │ 90.0  │
+    # └───────┘
+
+.. _atan:
+
+ATAN
+----
+Compute inverse tangent of the input column (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+      }
+    )
+
+    df.sql("SELECT ATAN(a) AS ATAN FROM self")
+    # shape: (4, 1)
+    # ┌───────────┐
+    # │ ATAN      │
+    # │ ---       │
+    # │ f64       │
+    # ╞═══════════╡
+    # │ -0.785398 │
+    # │ -0.463648 │
+    # │ 0.463648  │
+    # │ 0.785398  │
+    # └───────────┘
+
+.. _atand:
+
+ATAND
+-----
+Compute inverse tangent of the input column (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+      }
+    )
+
+    df.sql("SELECT ATAND(a) AS ATAND FROM self")
+    # shape: (4, 1)
+    # ┌────────────┐
+    # │ ATAND      │
+    # │ ---        │
+    # │ f64        │
+    # ╞════════════╡
+    # │ -45.0      │
+    # │ -26.565051 │
+    # │ 26.565051  │
+    # │ 45.0       │
+    # └────────────┘
+
+.. _atan2:
+
+ATAN2
+-----
+Compute the inverse tangent of column_2/column_1 (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+        "b": [10, 20, 30, 40],
+      }
+    )
+
+    df.sql("SELECT ATAN2(a, b) AS ATAN2 FROM self")
+    # shape: (4, 1)
+    # ┌───────────┐
+    # │ ATAN2     │
+    # │ ---       │
+    # │ f64       │
+    # ╞═══════════╡
+    # │ -0.099669 │
+    # │ -0.024995 │
+    # │ 0.016665  │
+    # │ 0.024995  │
+    # └───────────┘
+
+.. _atan2d:
+
+ATAN2D
+------
+Compute the inverse tangent of column_2/column_1 (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "a": [-1.0, -0.5, 0.5, 1],
+        "b": [10, 20, 30, 40],
+      }
+    )
+
+    df.sql("SELECT ATAN2D(a, b) AS ATAN2D FROM self")
+    # shape: (4, 1)
+    # ┌───────────┐
+    # │ ATAN2D    │
+    # │ ---       │
+    # │ f64       │
+    # ╞═══════════╡
+    # │ -5.710593 │
+    # │ -1.432096 │
+    # │ 0.954841  │
+    # │ 1.432096  │
+    # └───────────┘
+
+.. _cot:
+
+COT
+---
+Compute the cotangent of the input column (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    import math
+
+    df = pl.DataFrame(
+      {
+        "angle": [0.0, math.pi/2, math.pi, 3*math.pi/2],
+      }
+    )
+
+    df.sql("SELECT COT(angle) AS COT FROM self")
+    # shape: (4, 1)
+    # ┌────────────┐
+    # │ COT        │
+    # │ ---        │
+    # │ f64        │
+    # ╞════════════╡
+    # │ inf        │
+    # │ 6.1232e-17 │
+    # │ -8.1656e15 │
+    # │ 1.8370e-16 │
+    # └────────────┘
+
+.. _cotd:
+
+COTD
+----
+Compute cotangent of the input column (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "angle": [0, 90, 180, 270]
+      }
+    )
+
+    df.sql("SELECT COTD(angle) AS COTD FROM self")
+    # shape: (4, 1)
+    # ┌────────────┐
+    # │ COTD       │
+    # │ ---        │
+    # │ f64        │
+    # ╞════════════╡
+    # │ inf        │
+    # │ 6.1232e-17 │
+    # │ -8.1656e15 │
+    # | 1.8370e-16 │
+    # └────────────┘
+
+.. _cos:
+
+COS
+---
+Compute the cosine of the input column (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    import math
+
+    df = pl.DataFrame(
+      {
+        "angle": [0.0, math.pi/2, math.pi, 3*math.pi/2],
+      }
+    )
+
+    df.sql("SELECT COS(angle) AS COS FROM self")
+    # shape: (4, 1)
+    # ┌─────────────┐
+    # │ COS         │
+    # │ ---         │
+    # | f64         │
+    # ╞═════════════╡
+    # │ 1.0         │
+    # │ 6.1232e-17  │
+    # │ -1.0        │
+    # │ -1.8370e-16 │
+    # └─────────────┘
+
+.. _cosd:
+
+COSD
+----
+Compute the cosine of the input column (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "angle": [0, 90, 180, 270]
+      }
+    )
+
+    df.sql("SELECT COSD(angle) AS COSD FROM self")
+    # shape: (4, 1)
+    # ┌─────────────┐
+    # │ COSD        │
+    # │ ---         │
+    # | f64         │
+    # ╞═════════════╡
+    # │ 1.0         │
+    # │ 6.1232e-17  │
+    # │ -1.0        │
+    # │ -1.8370e-16 │
+    # └─────────────┘
+
+.. _degrees:
+
+DEGREES
+-------
+Convert between radians and degrees.
+
+**Example:**
+
+.. code-block:: python
+
+    import math
+
+    df = pl.DataFrame(
+      {
+        "angle": [0.0, math.pi/2, math.pi, 3*math.pi/2],
+      }
+    )
+
+    df.sql("SELECT DEGREES(angle) AS DEGREES FROM self")
+    # shape: (4, 1)
+    # ┌─────────┐
+    # │ DEGREES │
+    # │ ---     │
+    # │ f64     │
+    # ╞═════════╡
+    # │ 0.0     │
+    # │ 90.0    │
+    # │ 180.0   │
+    # │ 270.0   │
+    # └─────────┘
+
+.. _radians:
+
+RADIANS
+-------
+Convert between degrees and radians.
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "angle": [0, 90, 180, 270]
+      }
+    )
+
+    df.sql("SELECT RADIANS(angle_degrees) FROM self")
+    # shape: (4, 1)
+    # ┌───────────────┐
+    # │ angle_degrees │
+    # │ ---           │
+    # │ f64           │
+    # ╞═══════════════╡
+    # │ 0.0           │
+    # │ 1.570796      │
+    # │ 3.141593      │
+    # │ 4.712389      │
+    # └───────────────┘
+
+.. _sin:
+
+SIN
+---
+Compute the sine of the input column (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    import math
+
+    df = pl.DataFrame(
+      {
+        "angle": [0.0, math.pi/2, math.pi, 3*math.pi/2],
+      }
+    )
+
+    df.sql("SELECT SIN(angle) AS SIN FROM self")
+    # shape: (4, 1)
+    # ┌────────────┐
+    # │ SIN        │
+    # │ ---        │
+    # │ f64        │
+    # ╞════════════╡
+    # │ 0.0        │
+    # │ 1.0        │
+    # │ 1.2246e-16 │
+    # │ -1.0       │
+    # └────────────┘
+
+.. _sind:
+
+SIND
+----
+Compute the sine of the input column (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+    df = pl.DataFrame(
+      {
+        "angle": [0, 90, 180, 270]
+      }
+    )
+
+    df.sql("SELECT SIND(angle) FROM self")
+    # shape: (4, 1)
+    # ┌────────────┐
+    # │ SIND       │
+    # │ ---        │
+    # | f64        │
+    # ╞════════════╡
+    # │ 0.0        │
+    # │ 1.0        │
+    # │ 1.2246e-16 │
+    # │ -1.0       │
+    # └────────────┘
+
+.. _tan:
+
+TAN
+---
+Compute the tangent of the input column (in radians).
+
+**Example:**
+
+.. code-block:: python
+
+    import math
+
+    df = pl.DataFrame(
+      {
+        "angle": [0.0, math.pi/2, math.pi, 3*math.pi/2],
+      }
+    )
+
+    df.sql("SELECT TAN(angle) AS TAN FROM self")
+    # shape: (4, 1)
+    # ┌─────────────┐
+    # │ TAN         │
+    # │ ---         │
+    # │ f64         │
+    # ╞═════════════╡
+    # │ 0.0         │
+    # │ 1.6331e16   │
+    # │ -1.2246e-16 │
+    # │ 5.4437e15   │
+    # └─────────────┘
+
+
+.. _tand:
+
+TAND
+----
+Compute the tangent of the input column (in degrees).
+
+**Example:**
+
+.. code-block:: python
+
+
+    df = pl.DataFrame(
+      {
+        "angle": [0, 90, 180, 270]
+      }
+    )
+
+    df.sql("SELECT TAND(angle) AS TAND FROM self")
+    # shape: (4, 1)
+    # ┌─────────────┐
+    # │ TAND        │
+    # │ ---         │
+    # │ f64         │
+    # ╞═════════════╡
+    # │ 0.0         │
+    # │ 1.6331e16   │
+    # │ -1.2246e-16 │
+    # │ 5.4437e15   │
+    # └─────────────┘
diff --git a/py-polars/docs/source/reference/sql/index.rst b/py-polars/docs/source/reference/sql/index.rst
new file mode 100644
index 000000000000..99bd169fef53
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/index.rst
@@ -0,0 +1,72 @@
+=============
+SQL Interface
+=============
+
+This page gives an overview of all public SQL functions
+and operations supported by Polars.
+
+
+.. raw:: html
+
+    <style>
+      div.sd-card-body.docutils li.toctree-l1 > :first-child {display: none;}
+    </style>
+
+
+.. grid::
+
+    .. grid-item-card::
+
+        **Python API**
+        ^^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           python_api
+
+    .. grid-item-card::
+
+        **SQL Clauses**
+        ^^^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           clauses
+
+    .. grid-item-card::
+
+        **SQL Functions**
+        ^^^^^^^^^^^^^^^^^
+
+        :doc:`Overview <functions/index>`
+
+        .. toctree::
+           :maxdepth: 2
+
+           functions/index
+
+.. grid::
+
+    .. grid-item-card::
+
+        **Set Operations**
+        ^^^^^^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           set_operations
+
+    .. grid-item-card::
+
+        **Table Operations**
+        ^^^^^^^^^^^^^^^^^^^^
+
+        .. toctree::
+           :maxdepth: 2
+
+           table_operations
+
+    .. grid-item-card::
diff --git a/py-polars/docs/source/reference/sql.rst b/py-polars/docs/source/reference/sql/python_api.rst
similarity index 81%
rename from py-polars/docs/source/reference/sql.rst
rename to py-polars/docs/source/reference/sql/python_api.rst
index 5010ed54d611..504c6ca9725c 100644
--- a/py-polars/docs/source/reference/sql.rst
+++ b/py-polars/docs/source/reference/sql/python_api.rst
@@ -1,10 +1,13 @@
-=============
-SQL Interface
-=============
+==========
+Python API
+==========
+
+SQLContext
+----------
 .. currentmodule:: polars
 
-Polars provides a SQL interface to query frame data; this is available
-through the :class:`SQLContext` object, detailed below, and the DataFrame
+Polars provides a SQL interface to query frame data; this is available through
+the :class:`SQLContext` object, detailed below, as well as the DataFrame
 :meth:`~polars.DataFrame.sql` and LazyFrame :meth:`~polars.LazyFrame.sql`
 methods (which make use of SQLContext internally).
 
@@ -21,7 +24,7 @@ methods (which make use of SQLContext internally).
     .. automethod:: __exit__
 
 Methods
--------
+~~~~~~~
 
 .. autosummary::
    :toctree: api/
diff --git a/py-polars/docs/source/reference/sql/set_operations.rst b/py-polars/docs/source/reference/sql/set_operations.rst
new file mode 100644
index 000000000000..7ea0e4d5d8e9
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/set_operations.rst
@@ -0,0 +1,121 @@
+Set Operations
+==============
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`UNION <union>`
+     - Combine the distinct result sets of two or more SELECT statements.
+       The final result set will have no duplicate rows.
+   * - :ref:`UNION ALL <union_all>`
+     - Combine the complete result sets of two or more SELECT statements.
+       The final result set will be composed of all rows from each query.
+   * - :ref:`UNION [ALL] BY NAME <union_by_name>`
+     - Combine the result sets of two or more SELECT statements, aligning columns
+       by name instead of by ordinal position; if `ALL` is omitted the final result
+       will have no duplicate rows. This also combines columns from both datasets.
+
+
+.. _union:
+
+UNION
+-----
+Combine the distinct result sets of two or more SELECT statements.
+The final result set will have no duplicate rows.
+
+**Example:**
+
+.. code-block:: python
+
+    lf1 = pl.LazyFrame({
+        "id": [1, 2, 3],
+        "name": ["Alice", "Bob", "Charlie"],
+    })
+    lf2 = pl.LazyFrame({
+        "id": [2, 3, 4],
+        "age": [30, 25, 45],
+        "name": ["Bob", "Charlie", "David"],
+    })
+    lf_union = pl.sql("""
+        SELECT id, name FROM df1
+        UNION
+        SELECT id, name FROM df2
+    """).sort(by="id").collect()
+
+    # shape: (4, 2)
+    # ┌─────┬─────────┐
+    # │ id  ┆ name    │
+    # │ --- ┆ ---     │
+    # │ i64 ┆ str     │
+    # ╞═════╪═════════╡
+    # │ 1   ┆ Alice   │
+    # │ 2   ┆ Bob     │
+    # │ 3   ┆ Charlie │
+    # │ 4   ┆ David   │
+    # └─────┴─────────┘
+
+.. _union_all:
+
+UNION ALL
+---------
+Combine the complete result sets of two or more SELECT statements.
+The final result set will be composed of all rows from each query.
+
+**Example:**
+
+.. code-block:: python
+
+    lf_union_all = pl.sql("""
+        SELECT id, name FROM df1
+        UNION ALL
+        SELECT id, name FROM df2
+    """).sort(by="id").collect()
+
+    # shape: (6, 2)
+    # ┌─────┬─────────┐
+    # │ id  ┆ name    │
+    # │ --- ┆ ---     │
+    # │ i64 ┆ str     │
+    # ╞═════╪═════════╡
+    # │ 1   ┆ Alice   │
+    # │ 2   ┆ Bob     │
+    # │ 2   ┆ Bob     │
+    # │ 3   ┆ Charlie │
+    # │ 3   ┆ Charlie │
+    # │ 4   ┆ David   │
+    # └─────┴─────────┘
+
+.. _union_by_name:
+
+UNION BY NAME
+-------------
+Combine the result sets of two or more SELECT statements, aligning columns
+by name instead of by ordinal position; if `ALL` is omitted the final result
+will have no duplicate rows. This also combines columns from both datasets.
+
+**Example:**
+
+.. code-block:: python
+
+    lf_union_by_name = pl.sql("""
+        SELECT * FROM df1
+        UNION BY NAME
+        SELECT * FROM df2
+    """).sort(by="id").collect()
+
+    # shape: (6, 3)
+    # ┌─────┬─────────┬──────┐
+    # │ id  ┆ name    ┆ age  │
+    # │ --- ┆ ---     ┆ ---  │
+    # │ i64 ┆ str     ┆ i64  │
+    # ╞═════╪═════════╪══════╡
+    # │ 1   ┆ Alice   ┆ null │
+    # │ 2   ┆ Bob     ┆ null │
+    # │ 2   ┆ Bob     ┆ 30   │
+    # │ 3   ┆ Charlie ┆ 25   │
+    # │ 3   ┆ Charlie ┆ null │
+    # │ 4   ┆ David   ┆ 45   │
+    # └─────┴─────────┴──────┘
diff --git a/py-polars/docs/source/reference/sql/table_operations.rst b/py-polars/docs/source/reference/sql/table_operations.rst
new file mode 100644
index 000000000000..61e2576ccb63
--- /dev/null
+++ b/py-polars/docs/source/reference/sql/table_operations.rst
@@ -0,0 +1,98 @@
+Table Operations
+================
+
+.. list-table::
+   :header-rows: 1
+   :widths: 20 60
+
+   * - Function
+     - Description
+   * - :ref:`CREATE TABLE <create_table>`
+     - Create a new table and its columns from a SQL query against an existing table.
+   * - :ref:`DROP TABLES <drop_tables>`
+     - Delete a specified table and related data.
+   * - :ref:`EXPLAIN <explain>`
+     - Returns logical plan of the query.
+   * - :ref:`SHOW TABLES <show_tables>`
+     - Returns a list of all tables in the context.
+   * - :ref:`UNNEST <unnest_table_func>`
+     - Unnest one or more arrays as columns in a new table.
+   * - :ref:`TRUNCATE <truncate>`
+     - Remove rows from table without deleting the table from context.
+
+.. _create_table:
+
+CREATE TABLE
+------------
+Create a new table and its columns from a SQL query against an existing table.
+
+**Example:**
+
+.. code-block:: sql
+
+    CREATE TABLE new_table AS SELECT * FROM df WHERE value > 42
+
+.. _drop_tables:
+
+DROP TABLES
+-----------
+Delete a specified table and related data.
+
+**Example:**
+
+.. code-block:: sql
+
+    DROP TABLE old_table
+
+.. _explain:
+
+EXPLAIN
+-------
+Returns Logical Plan of the query.
+
+**Example:**
+
+.. code-block:: sql
+
+    EXPLAIN SELECT * FROM df
+
+.. _show_tables:
+
+SHOW TABLES
+-----------
+Display the list of tables in the context.
+
+**Example:**
+
+.. code-block:: sql
+
+    SHOW TABLES
+
+.. _unnest_table_func:
+
+UNNEST
+------
+Unnest one or more arrays as columns in a new table.
+
+**Example:**
+
+.. code-block:: sql
+
+    SELECT * FROM
+      UNNEST(
+        [1, 2, 3, 4],
+        ['ww','xx','yy','zz'],
+        [23.0, 24.5, 28.0, 27.5]
+      ) AS tbl (x,y,z)
+
+.. _truncate:
+
+TRUNCATE
+--------
+Removes all rows from the specified table, but keeps the table.
+
+**Example:**
+
+.. code-block:: sql
+
+    TRUNCATE TABLE df