### Install Ibis with examples

Source: https://ibis-project.org/presentations/overview/index.html

Installs the Ibis framework along with example dependencies using pip.

```bash
pip install 'ibis-framework[duckdb,examples]'
```

--------------------------------

### Add Brief Installation Instructions at Top of Notebooks

Source: https://ibis-project.org/release_notes.html

Concise installation instructions have been added to the beginning of notebooks for quick setup.

```bash
# Install Ibis and necessary backends
pip install "ibis-framework[duckdb]"

```

--------------------------------

### Setup Ibis and Fetch Sample Data

Source: https://ibis-project.org/posts/ibis-version-6.0.0-release/index.html

Initializes Ibis with custom options and fetches the penguins dataset for demonstration. Ensure 'ibis-framework>=6,<7' is installed.

```python
import ibis
import ibis.selectors as s

ibis.options.interactive = True
ibis.options.repr.interactive.max_rows = 3
```

```python
t = ibis.examples.penguins.fetch()
t
```

--------------------------------

### Install Ibis with DuckDB Backend

Source: https://ibis-project.org/presentations/linkedin-meetup-2024-04-24.html

Installs the Ibis framework with the DuckDB backend using pip. This is the recommended way to get started with Ibis for local experimentation.

```bash
pip install 'ibis-framework[duckdb]'
```

--------------------------------

### Run Backend Tests After Starting

Source: https://ibis-project.org/community/contribute/02_workflow

Run the test suite for a specific backend after it has been started. For example, running PostgreSQL tests after starting the PostgreSQL backend.

```bash
pytest -m postgres
```

--------------------------------

### Load Example Data with Ibis

Source: https://ibis-project.org/how-to/visualization/marimo.html

Loads the example 'penguins' dataset using Ibis and displays the first few rows. Ensure Ibis is installed and configured for interactive use.

```python
import ibis
import ibis.selectors as s

ibis.options.interactive = True

penguins = ibis.examples.penguins.fetch()
penguins.head(3)
```

--------------------------------

### Install Development Dependencies with `just sync`

Source: https://ibis-project.org/community/contribute/01_environment

This command uses `just` to set up the development environment, creating a virtual environment and installing dependencies. It also installs Ibis in development mode.

```shell
just sync
```

--------------------------------

### Load Example Data with Ibis

Source: https://ibis-project.org/how-to/configure/basics.html

Load the penguins dataset from the ibis.examples module. Ensure Ibis is installed first.

```python
import ibis

t = ibis.examples.penguins.fetch()
```

--------------------------------

### Install the Unix backend for Ibis

Source: https://ibis-project.org/posts/unix-backend/index.html

Install the `ibish` package using pip. Ensure you have the latest commit of `ibis-framework` installed as a dependency.

```bash
pip install ibish
```

--------------------------------

### Add how-to for working with raw SQL strings

Source: https://ibis-project.org/release_notes.html

A new how-to guide has been added to explain how to work with raw SQL strings within the Ibis framework, providing examples and best practices.

```python
add how-to for working with raw sql strings (3e08556)
```

--------------------------------

### Setup Ibis and Fetch Sample Data

Source: https://ibis-project.org/posts/ibis-version-8.0.0-release

Configure Ibis options for interactive use and set the maximum number of rows to display. This snippet is essential for following along with the examples in this release.

```python
import ibis
import ibis.selectors as s

ibis.options.interactive = True
ibis.options.repr.interactive.max_rows = 3
```

--------------------------------

### Install Docker Client with Homebrew

Source: https://ibis-project.org/contribute/02_workflow.html

Installs the Docker client using Homebrew. Ensure your Homebrew installation is up to date before running this command.

```bash
$ brew install docker
```

--------------------------------

### Install PyTorch

Source: https://ibis-project.org/how-to/input-output/basics.html

Install the PyTorch library to enable tensor conversions.

```bash
pip install torch
```

--------------------------------

### Build and Preview Documentation

Source: https://ibis-project.org/community/contribute/01_environment

Install `just` and run this command to build and serve the documentation locally. Ensure `just` is installed, or if using conda/mamba, it should be included.

```bash
just docs-preview
```

--------------------------------

### Setup for Penguin Dataset with Ibis

Source: https://ibis-project.org/posts/duckdb-for-rag/index.html

This Python code initializes Ibis and sets up options for data processing, likely for use with the 'penguins' dataset. It's a common starting point for examples involving Ibis and data analysis.

```python
import ibis
import ibis.selectors as s

ibis.options.interactive.mode = "off"
ibis.options.sql.default_limit = 10000
ibis.options.data_types.allow_missing = True
ibis.options.catalogs.default = "memory"

# Load the penguins dataset
df = ibis.examples.penguins.load()
```

--------------------------------

### Build and Preview Documentation

Source: https://ibis-project.org/contribute/01_environment.html

Builds and serves the Ibis documentation locally. Requires 'just' to be installed.

```bash
just docs-preview
```

--------------------------------

### Drop `docker-compose` Install for Conda Dev Env Setup

Source: https://ibis-project.org/release_notes.html

The `docker-compose` installation step has been removed from the Conda development environment setup.

```bash
# Conda environment setup script
# ... other commands ...

# docker-compose install removed

```

--------------------------------

### Example Connection and Table Listing

Source: https://ibis-project.org/backends/singlestoredb.html

Demonstrates connecting to SingleStoreDB using environment variables for credentials and listing tables. It also shows how to access a specific table and display its schema.

```python
>>> import os
>>> import ibis
>>> host = os.environ.get("IBIS_TEST_SINGLESTOREDB_HOST", "localhost")
>>> user = os.environ.get("IBIS_TEST_SINGLESTOREDB_USER", "root")
>>> password = os.environ.get("IBIS_TEST_SINGLESTOREDB_PASSWORD", "ibis_testing")
>>> database = os.environ.get("IBIS_TEST_SINGLESTOREDB_DATABASE", "ibis_testing")
>>> port = int(os.environ.get("IBIS_TEST_SINGLESTOREDB_PORT", "3307"))
>>> con = ibis.singlestoredb.connect(
...     database=database, host=host, user=user, password=password, port=port
... )
>>> con.list_tables()
[...]
>>> t = con.table("functional_alltypes")
>>> t
DatabaseTable: functional_alltypes
  id              int32
  bool_col        boolean
  tinyint_col     int8
  smallint_col    int16
  int_col         int32
  bigint_col      int64
  float_col       float32
  double_col      float64
  date_string_col string
  string_col      string
  timestamp_col   timestamp
  year            int32
  month           int32
```

--------------------------------

### Fetch Billboard Example Data

Source: https://ibis-project.org/reference/expression-tables.html

Fetches the example billboard dataset. This is a common starting point for exploring Ibis functionalities.

```python
billboard = ibis.examples.billboard.fetch()
billboard
```

--------------------------------

### Example Oracle Connection and Table Listing

Source: https://ibis-project.org/backends/oracle.html

Demonstrates establishing an Oracle connection using environment variables for credentials and then listing tables in the database. This example requires environment variables to be set for host, user, and password.

```python
import os
import ibis
host = os.environ.get("IBIS_TEST_ORACLE_HOST", "localhost")
user = os.environ.get("IBIS_TEST_ORACLE_USER", "ibis")
password = os.environ.get("IBIS_TEST_ORACLE_PASSWORD", "ibis")
database = os.environ.get("IBIS_TEST_ORACLE_DATABASE", "IBIS_TESTING")
con = ibis.oracle.connect(database=database, host=host, user=user, password=password)
con.list_tables()
```

--------------------------------

### More Group By() and NULL in Pandas Guide

Source: https://ibis-project.org/release_notes.html

The pandas guide has been updated with more examples covering `group_by()` operations and NULL value handling.

```python
import ibis

expr = ibis.table('my_table')
grouped = expr.group_by('category').aggregate(total=ibis.sum('value'))

```

--------------------------------

### Start Client-Server Backends

Source: https://ibis-project.org/community/contribute/02_workflow

Start various client-server backends using the 'just' tool. These backends need to be running before their respective tests can be executed.

```bash
just up clickhouse
```

```bash
just up exasol
```

```bash
just up flink
```

```bash
just up impala
```

```bash
just up mssql
```

```bash
just up mysql
```

```bash
just up oracle
```

```bash
just up postgres
```

```bash
just up risingwave
```

```bash
just up trino
```

```bash
just up druid
```

--------------------------------

### Load Example Penguins Dataset with Ibis

Source: https://ibis-project.org/how-to/visualization/altair.html

Loads the example penguins dataset into an Ibis table. Ensure Ibis is installed and configured.

```python
import ibis
import ibis.selectors as s

ibis.options.interactive = True

t = ibis.examples.penguins.fetch()
t.head(3)
```

--------------------------------

### Generate Example Registry (With R Dependencies)

Source: https://ibis-project.org/contribute/04_maintainers_guide.html

Use this Nix command from the git root of an ibis clone to generate the example registry, including R dependencies.

```bash
nix run '.#gen-examples'
```

--------------------------------

### Install Pixi Global gh

Source: https://ibis-project.org/contribute/01_environment.html

Installs the GitHub CLI tool 'gh' globally using Pixi. This is part of the Pixi-based setup.

```bash
pixi global install gh
```

--------------------------------

### Load Example Datasets in Ibis

Source: https://ibis-project.org/tutorials/coming-from/dplyr.html

Load example datasets 'band_members' and 'band_instruments' using ibis.examples.fetch().

```python
band_members = ibis.examples.band_members.fetch()
band_instruments = ibis.examples.band_instruments.fetch()
```

--------------------------------

### Fetch Example Dataset

Source: https://ibis-project.org/presentations/linkedin-meetup-2024-04-24.html

Imports necessary Ibis functions and fetches the 'penguins' example dataset. This is the starting point for many Ibis operations.

```python
from ibis.interactive import *

penguins = ibis.examples.penguins.fetch()
penguins
```

--------------------------------

### Start backend services with 'just'

Source: https://ibis-project.org/contribute/02_workflow.html

Start specific backend services using the 'just' tool. This is required for testing client-server backends.

```bash
just up clickhouse
```

```bash
just up exasol
```

```bash
just up flink
```

```bash
just up impala
```

```bash
just up mssql
```

```bash
just up mysql
```

```bash
just up oracle
```

```bash
just up postgres
```

```bash
just up risingwave
```

```bash
just up trino
```

```bash
just up druid
```

--------------------------------

### Get Start Point of a LineString

Source: https://ibis-project.org/reference/expression-geospatial.html

This snippet retrieves the starting point of a LineString geometry. It requires loading the spatial extension and creating a literal LineString.

```python
import ibis
ibis.options.interactive = True
con = ibis.get_backend()
con.load_extension("spatial")
import shapely
line = shapely.LineString([[0, 0], [1, 0], [1, 1]])
line_lit = ibis.literal(line, type="geometry")
line_lit.start_point()
```

--------------------------------

### Download example data for tests

Source: https://ibis-project.org/contribute/02_workflow.html

Download necessary example data to run backend tests successfully. This is a prerequisite for running most backend-specific tests.

```bash
just download-data
```

--------------------------------

### Load and Inspect Penguin Dataset with Ibis

Source: https://ibis-project.org/presentations/linkedin-meetup-2024-04-24.html

Loads the example penguins dataset using Ibis and displays the first few rows. This is a basic example to verify the Ibis installation and data loading.

```python
from ibis.interactive import *

t = ibis.examples.penguins.fetch()
t.head()
```

--------------------------------

### Installation

Source: https://ibis-project.org/backends/singlestoredb.html

Instructions for installing the Ibis framework with SingleStoreDB support using pip, conda, or mamba.

```APIDOC
## Installation

Install Ibis and dependencies for the SingleStoreDB backend:

### Using pip
```
pip install 'ibis-framework[singlestoredb]'
```

### Using conda
```
conda install -c conda-forge ibis-singlestoredb
```

### Using mamba
```
mamba install -c conda-forge ibis-singlestoredb
```
```

--------------------------------

### Top 10 Start Stations using topk

Source: https://ibis-project.org/posts/ibis-duckdb-geospatial-dev-guru

An alternative method to find the top 10 start stations using the `topk` operation in Ibis. This provides a concise way to get the most frequent elements.

```python
biketrip.start_station_name.topk(10)
```

--------------------------------

### Start Colima Instance

Source: https://ibis-project.org/contribute/02_workflow.html

Starts a Colima instance, which provides a Docker Engine. By default, it launches with 2 CPUs, 2GB RAM, and 60GB disk space. Arguments like `--cpu`, `--memory`, `--disk`, and `--arch` can modify these defaults.

```bash
$ colima start
```

--------------------------------

### Install ibis-bench

Source: https://ibis-project.org/posts/ibis-bench

Install the ibis-bench package using pip. This is the first step to running benchmarks.

```bash
pip install ibis-bench
```

--------------------------------

### Check Ibis Version

Source: https://ibis-project.org/posts/v6.1.0-release/index.html

Prints the currently installed Ibis version. This example assumes Ibis is already imported.

```python
ibis.__version__
```

--------------------------------

### Connect to PostgreSQL with Environment Variables

Source: https://ibis-project.org/backends/postgresql.html

Connect to a PostgreSQL database using `ibis.postgres.connect`, retrieving connection details from environment variables. This example also demonstrates listing tables and accessing a table.

```python
import os
import ibis
host = os.environ.get("IBIS_TEST_POSTGRES_HOST", "localhost")
user = os.environ.get("IBIS_TEST_POSTGRES_USER", "postgres")
password = os.environ.get("IBIS_TEST_POSTGRES_PASSWORD", "postgres")
database = os.environ.get("IBIS_TEST_POSTGRES_DATABASE", "ibis_testing")
con = ibis.postgres.connect(database=database, host=host, user=user, password=password)
con.list_tables()
t = con.table("functional_alltypes")
t
```

--------------------------------

### Connect to PySpark using ibis.pyspark.connect (pip)

Source: https://ibis-project.org/backends/pyspark.html

Connect to a PySpark backend after installing with pip. This is a basic connection setup.

```python
import ibis

1con = ibis.pyspark.connect()
```

--------------------------------

### Install Kaggle CLI and Download Competition Data

Source: https://ibis-project.org/posts/ibisml

Installs the Kaggle CLI and downloads the data for the credit risk model stability competition.

```bash
pip install kaggle
kaggle competitions download -c home-credit-credit-risk-model-stability
unzip home-credit-credit-risk-model-stability.zip
```

--------------------------------

### Geospatial Support Setup

Source: https://ibis-project.org/backends/duckdb.html

Enable experimental geospatial operations in the DuckDB backend by installing the `geospatial` extra or the required dependencies.

```APIDOC
## Geospatial Support Setup

### Description
Enable experimental geospatial operations in the DuckDB backend by installing the `geospatial` extra or the required dependencies.

### Installation

#### Pip
```bash
pip install 'ibis-framework[geospatial]'
```

#### Conda
```bash
conda install -c conda-forge ibis-framework geopandas 'shapely>=2,<3'
```

#### Mamba
```bash
mamba install -c conda-forge ibis-framework geopandas 'shapely>=2,<3'
```

### Notes
Refer to `read_geo` for tips on reading geospatial data.
```

--------------------------------

### Installation

Source: https://ibis-project.org/backends/risingwave.html

Instructions for installing the Ibis RisingWave backend using pip, conda, or mamba.

```APIDOC
## Installation

Install Ibis and dependencies for the RisingWave backend:

### Using pip

Install with the `risingwave` extra:
```
pip install 'ibis-framework[risingwave]'
```

And connect:
```python
import ibis

con = ibis.risingwave.connect()
```

Adjust connection parameters as needed.

### Using conda

Install for RisingWave:
```bash
conda install -c conda-forge ibis-risingwave
```

And connect:
```python
import ibis

con = ibis.risingwave.connect()
```

Adjust connection parameters as needed.

### Using mamba

Install for RisingWave:
```bash
mamba install -c conda-forge ibis-risingwave
```

And connect:
```python
import ibis

con = ibis.risingwave.connect()
```

Adjust connection parameters as needed.
```

--------------------------------

### Install Ibis with SingleStoreDB Extra

Source: https://ibis-project.org/backends/singlestoredb.html

Install the Ibis framework with the necessary dependencies for the SingleStoreDB backend using pip.

```bash
pip install 'ibis-framework[singlestoredb]'
```

--------------------------------

### Fetch and Display Penguins Dataset

Source: https://ibis-project.org/reference/expression-tables.html

Fetches the penguins dataset and displays its initial structure and content. This is a common starting point for examples.

```python
import ibis
import ibis.selectors as s
ibis.options.interactive = True
t = ibis.examples.penguins.fetch()
t
```

--------------------------------

### Connect to DataFusion and Get Tables

Source: https://ibis-project.org/posts/ibis-bench

Establishes a connection to a DataFusion backend and retrieves specified Ibis tables. Ensure DataFusion is installed and accessible.

```python
con = ibis.connect("datafusion://")

(customer, lineitem, nation, orders, part, partsupp, region, supplier) = (
    get_ibis_tables(sf=sf, con=con)
)
```

--------------------------------

### Exasol Connection Example with Environment Variables

Source: https://ibis-project.org/backends/exasol.html

Create an Ibis client connected to an Exasol database using environment variables for connection details. This example also demonstrates listing tables and accessing a table.

```python
>>> import os
>>> import ibis
>>> host = os.environ.get("IBIS_TEST_EXASOL_HOST", "localhost")
>>> user = os.environ.get("IBIS_TEST_EXASOL_USER", "sys")
>>> password = os.environ.get("IBIS_TEST_EXASOL_PASSWORD", "exasol")
>>> schema = os.environ.get("IBIS_TEST_EXASOL_DATABASE", "EXASOL")
>>> con = ibis.exasol.connect(schema=schema, host=host, user=user, password=password)
>>> con.list_tables()
[...]
>>> t = con.table("functional_alltypes")
>>> t
DatabaseTable: functional_alltypes
  id              int32
  bool_col        boolean
  tinyint_col     int16
  smallint_col    int16
  int_col         int32
  bigint_col      int64
  float_col       float64
  double_col      float64
  date_string_col string(256)
  string_col      string(256)
  timestamp_col   timestamp(3)
  year            int32
  month           int32
```

--------------------------------

### Format Bulleted List Item

Source: https://ibis-project.org/contribute/03_style.html

Example of correctly wrapping a long bulleted sentence. Ensure wrapped lines align with the start of the bulleted text.

```markdown
* This is a long sentence that is a bulleted sentence and perhaps it shouldn't
  have been a bullet but it got away from me and, well, here we are.
```

--------------------------------

### Examples: `mean`, `bucket`, `histogram`

Source: https://ibis-project.org/release_notes.html

Provides examples for calculating the mean, creating buckets, and generating histograms using Ibis. These are common statistical and data visualization operations.

```python
import ibis

t = ibis.table("t", schema=dict(x=ibis.schema.float))

t.mutate(mean_x=ibis.mean(t.x))

```

--------------------------------

### Create a sample Ibis table

Source: https://ibis-project.org/reference/expression-tables.html

Initializes a sample in-memory table for demonstrating sorting operations. This setup is required before applying order_by.

```python
import ibis
ibis.options.interactive = True
t = ibis.memtable(
    {
        "a": [3, 2, 1, 3],
        "b": ["a", "B", "c", "D"],
        "c": [4, 6, 5, 7],
    }
)
t
```

--------------------------------

### Installation

Source: https://ibis-project.org/backends/sqlite.html

Instructions for installing the Ibis SQLite backend using different package managers.

```APIDOC
## Installation

Install Ibis and dependencies for the SQLite backend:

### Using pip
```
pip install 'ibis-framework[sqlite]'
```

__
And connect:
```python
import ibis

con = ibis.sqlite.connect()
```

__ 
1
     Adjust connection parameters as needed.

### Using conda
Install for SQLite:
```
conda install -c conda-forge ibis-sqlite
```

__
And connect:
```python
import ibis

con = ibis.sqlite.connect()
```

__ 
1
     Adjust connection parameters as needed.

### Using mamba
Install for SQLite:
```
mamba install -c conda-forge ibis-sqlite
```

__
And connect:
```python
import ibis

con = ibis.sqlite.connect()
```

__ 
1
     Adjust connection parameters as needed.
```

--------------------------------

### Sort using selectors (startswith)

Source: https://ibis-project.org/reference/expression-tables.html

Applies sorting to columns that start with 'year' using the `s.startswith` selector. This example fetches the penguins dataset and counts values before sorting.

```python
import ibis.selectors as s
penguins = ibis.examples.penguins.fetch()
penguins[["year", "island"]].value_counts().order_by(s.startswith("year"))
```

--------------------------------

### Load WoW AH Raw Data with Ibis

Source: https://ibis-project.org/posts/wow-analysis/index.html

Imports the Ibis library and loads the raw World of Warcraft Auction House data. Ensure you have installed ibis-framework[duckdb,examples].

```python
from ibis.interactive import *

wowah_data = ex.wowah_data_raw.fetch()

wowah_data
```

--------------------------------

### Installation and Basic Connection

Source: https://ibis-project.org/backends/materialize.html

Instructions for installing the Ibis Materialize backend and establishing a basic connection.

```APIDOC
## Install
Install Ibis and dependencies for the Materialize backend:
```
pip install 'ibis-framework[materialize]'
```

__
And connect:
```python
import ibis

con = ibis.materialize.connect()
```

__ 

1
     Adjust connection parameters as needed.
```

--------------------------------

### Create a ClickHouse client using default parameters

Source: https://ibis-project.org/backends/clickhouse.html

This example demonstrates creating a ClickHouse client instance using the default connection parameters provided by `ibis.clickhouse.connect()`.

```python
import ibis
client = ibis.clickhouse.connect()
client
```

--------------------------------

### Connect to Oracle using ibis.oracle.connect

Source: https://ibis-project.org/backends/oracle.html

Demonstrates how to establish a connection to an Oracle database using the `ibis.oracle.connect` function with explicit parameters.

```APIDOC
## Connect to Oracle using ibis.oracle.connect

```python
con = ibis.oracle.connect(
    user="username",
    password="password",
    host="hostname",
    port=1521,
    database="database",
)
```

This function is a thin wrapper around `ibis.backends.oracle.Backend.do_connect`.
```

--------------------------------

### Install Ibis for Databricks using Conda

Source: https://ibis-project.org/backends/databricks.html

Install the ibis-databricks package from the conda-forge channel. This is an alternative installation method.

```bash
conda install -c conda-forge ibis-databricks

```

--------------------------------

### Parquet Documentation

Source: https://ibis-project.org/release_notes.html

Includes docstring examples for the `to_parquet` function, covering partitioning.

```APIDOC
## Parquet Documentation

### Description
Docstring examples for the `to_parquet` function, including details on partitioning.

### Method
N/A (Documentation Update)

### Endpoint
N/A
```

--------------------------------

### Fix Typo in Pip Install Command for Backends

Source: https://ibis-project.org/release_notes.html

Corrected a typo in the pip install command used for backend installations.

```bash
pip install "ibis-framework[pandas]"
```

--------------------------------

### Install pre-commit Hook

Source: https://ibis-project.org/contribute/03_style.html

Installs the pre-commit hook for automatic code linting before committing. Ensure pre-commit is installed first.

```bash
pip install pre-commit
```

--------------------------------

### Add Docstring Examples for `to_parquet` including Partitioning

Source: https://ibis-project.org/release_notes.html

This commit adds comprehensive docstring examples for the `to_parquet` function, demonstrating its usage with partitioning options.

```python
Parquet `to_parquet` Examples

Demonstrates how to use the `to_parquet` method to write Ibis tables to Parquet files, including examples of how to specify partitioning schemes.

Example:
```python
table.to_parquet('output_directory', partition_by=['year', 'month'])
```
```

--------------------------------

### Install gh using Conda

Source: https://ibis-project.org/contribute/01_environment.html

Installs the GitHub CLI tool 'gh' using Conda. Ensure you have Miniconda installed.

```bash
conda install -c conda-forge gh
```

--------------------------------

### Add Examples to `if_any` and `if_all`

Source: https://ibis-project.org/release_notes.html

Examples have been added to illustrate the usage of `if_any` and `if_all` functions.

```python
import ibis

expr = """
SELECT
  *, 
  if_any(a, b, c) OVER (PARTITION BY d) AS any_a_b_c,
  if_all(a, b, c) OVER (PARTITION BY d) AS all_a_b_c
FROM
  t
"""

```

--------------------------------

### Install Ibis for PySpark with conda

Source: https://ibis-project.org/backends/pyspark.html

Install the ibis-pyspark package using conda from the conda-forge channel. This is an alternative installation method.

```bash
conda install -c conda-forge ibis-pyspark
```

--------------------------------

### Creating a Partitioned Table

Source: https://ibis-project.org/backends/impala.html

Illustrates how to create an empty table that is partitioned by specified columns.

```APIDOC
## POST /api/tables/partitioned (create_table)

### Description
Creates an empty table partitioned by the specified columns.

### Method
POST

### Endpoint
/api/tables/partitioned

### Parameters
#### Request Body
- **name** (string) - Required - The name of the table to create.
- **schema** (object) - Required - An Ibis schema object defining the table structure.
- **partition** (array) - Required - A list of column names to use as partition keys.

### Request Example
```json
{
  "name": "new_table",
  "schema": {
    "foo": "string",
    "year": "int32",
    "month": "int16"
  },
  "partition": ["year", "month"]
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message that the partitioned table was created.

#### Response Example
```json
{
  "message": "Partitioned table 'new_table' created successfully."
}
```
```

--------------------------------

### Install Ibis with Druid using Conda

Source: https://ibis-project.org/backends/druid.html

Install the ibis-druid package from conda-forge using conda. This is an alternative installation method.

```bash
conda install -c conda-forge ibis-druid
```

--------------------------------

### Installation

Source: https://ibis-project.org/backends/flink.html

Install Ibis and dependencies for the Flink backend using pip. It's recommended to install alongside the `apache-flink` package.

```APIDOC
## Install Ibis Flink Backend

Install alongside the `apache-flink` package:

```bash
pip install ibis-framework apache-flink
```

Then, connect to the Flink backend:

```python
import ibis

con = ibis.flink.connect()
```
```

--------------------------------

### Installation

Source: https://ibis-project.org/backends/mysql.html

Instructions for installing Ibis with MySQL support using pip, conda, or mamba.

```APIDOC
## Installation

Install Ibis and dependencies for the MySQL backend:

### Using pip
```
pip install 'ibis-framework[mysql]'
```

### Using conda
```
conda install -c conda-forge ibis-mysql
```

### Using mamba
```
mamba install -c conda-forge ibis-mysql
```
```

--------------------------------

### Install Ibis with Backends

Source: https://ibis-project.org/posts/1brc

Install the Ibis framework along with the necessary backends for DuckDB, Polars, and DataFusion.

```bash
pip install 'ibis-framework[duckdb,polars,datafusion]'
```

--------------------------------

### Install Ibis SQLite using Conda

Source: https://ibis-project.org/install.html

Install the ibis-sqlite package using conda. This command installs the package from the conda-forge channel.

```bash
conda install -c conda-forge ibis-sqlite
```

--------------------------------

### Write Ibis Expression to Parquet File (Example 3)

Source: https://ibis-project.org/reference/expression-generic.html

Example demonstrating how to partition a parquet file by multiple columns using a temporary directory.

```python
penguins.to_parquet(tempfile.mkdtemp(), partition_by=("year", "island"))
```

--------------------------------

### Example of ibis.clickhouse.connect usage

Source: https://ibis-project.org/backends/ClickHouse

Demonstrates the basic usage of ibis.clickhouse.connect and the returned client object.

```python
>>> import ibis
>>> client = ibis.clickhouse.connect()
>>> client
<ibis.clickhouse.client.ClickhouseClient object at 0x...>
```

--------------------------------

### Install Ibis Flink using Conda

Source: https://ibis-project.org/install.html

Install the ibis-flink package using conda. This command installs the package from the conda-forge channel.

```bash
conda install -c conda-forge ibis-flink
```

--------------------------------

### Installation

Source: https://ibis-project.org/backends/impala.html

Instructions for installing the Ibis Impala backend using different package managers.

```APIDOC
## Installation

Install Ibis and dependencies for the Impala backend:

### Using pip
```
pip install 'ibis-framework[impala]'
```

And connect:
```python
import ibis

con = ibis.impala.connect()
```

__
1. Adjust connection parameters as needed.

### Using conda
Install for Impala:
```
conda install -c conda-forge ibis-impala
```

And connect:
```python
import ibis

con = ibis.impala.connect()
```

__
1. Adjust connection parameters as needed.

### Using mamba
Install for Impala:
```
mamba install -c conda-forge ibis-impala
```

And connect:
```python
import ibis

con = ibis.impala.connect()
```

__
1. Adjust connection parameters as needed.
```

--------------------------------

### Generate range with start and stop arguments

Source: https://ibis-project.org/reference/expression-generic.html

Creates a range of integers starting from the 'start' value (inclusive) up to the 'stop' value (exclusive).

```python
ibis.range(1, 5)
```