Ibis

https://ibis-project.org
Admin
Ibis is a portable Python dataframe library offering a unified API to work with data across various...
Tokens:894,996
Snippets:8,731
Trust Score:9.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### 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]"

```

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

### Install Ibis Framework

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

Install the Ibis framework with DuckDB and example support.

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

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

### 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 and examples

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

Command to install the necessary dependencies for working with the Ibis framework, DuckDB, and the example dataset.

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

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

### Initialize Ibis and fetch example data

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

Basic setup to initialize the Ibis interactive environment and load the penguins example dataset.

```python
from ibis.interactive import *

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

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

### 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
```

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

### 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
```

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

### 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
```

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

### 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()
```

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

### 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)
```

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

### Install Docker Client with Homebrew

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

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

```bash
$ brew install docker
```

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

### Install Altair

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

Install the Altair visualization library.

```bash
pip install altair
```

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

### Install scikit-learn

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

Command to install the scikit-learn library.

```bash
pip install scikit-learn
```

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

### 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
```

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

### Install plotnine

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

Install the plotnine visualization library.

```bash
pip install plotnine
```

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

### Examples: `asof_join` weather example

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

Provides an example of using `asof_join` with weather data in Ibis. This is useful for time-series data analysis where events need to be joined based on proximity in time.

```python
import ibis

weather = ibis.table("weather", schema=dict(time=ibis.schema.timestamp, temp=ibis.schema.float))
storms = ibis.table("storms", schema=dict(time=ibis.schema.timestamp, pressure=ibis.schema.float))

weather.asof_join(storms, on=weather.time, by=weather.temp > 50)

```

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

### 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()
```

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

### 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

```

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

### 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
```

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

### 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()
```

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

### 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
```

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

### 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'))

```

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

### Generate Example Registry (With R Dependencies)

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

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'
```

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

### 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()
```

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

### 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()
```

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

### 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
```

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

### 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)
```

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

### Download Example Data for Tests

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

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

```bash
just download-data
```

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

### 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()
```

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

### 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
```
```

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

### 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.
```

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

### Setup Mock Data

Source: https://ibis-project.org/posts/ffill-and-bfill-using-ibis/index.html

Create a pandas DataFrame with event IDs, dates, and null measurements to serve as the base for the Ibis examples.

```python
from datetime import date

import numpy as np
import pandas as pd

import ibis


df = pd.DataFrame(
    {
        "event_id": [0] * 2 + [1] * 3 + [2] * 5 + [3] * 2,
        "measured_on": map(
            date,
            [2021] * 12, [6] * 4 + [5] * 6 + [7] * 2,
            range(1, 13),
        ),
        "measurement": np.nan,
    }
)

df.head()
```

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

### Fetch and display a sample dataset

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

Demonstrates how to import the examples module, enable interactive mode, and fetch the penguins dataset.

```python
import ibis
import ibis.examples as ex

ibis.options.interactive = True

t = ex.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)
)
```

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

### 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
```

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

### 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"))
```

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

### 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
```

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

### 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 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

```

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

### 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]'
```

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

### 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]"
```

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

### 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
```

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

### 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
```

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

### 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
```

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

### 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 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.
```

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

### 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
```

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

### 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
```

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

### 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.
```

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

### 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`.
```

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

### 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)
```

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

### Install Ibis DuckDB using Conda

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

Install the ibis-duckdb package using conda. This command ensures the package is installed from the conda-forge channel.

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

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

### Initialize Ibis

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

Set up the Ibis library and enable interactive mode.

```python
import ibis

ibis.options.interactive = True
```

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

### Install gh with Nix env

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

Installs the GitHub CLI tool using `nix-env`. This command installs `gh` permanently into the user profile.

```bash
nix-env -iA gh
```

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

### 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
```

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

### Install Ibis with Snowflake support using conda

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

Install the ibis-snowflake package from conda-forge. This is an alternative installation method for users who prefer conda.

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

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

### Install Ibis with BigQuery Support using Conda

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

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

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

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

### 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 Ibis Exasol Backend with Conda

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

Install the Exasol backend for Ibis using conda. This is an alternative installation method for Exasol integration.

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

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

### 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."
}
```
```

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

### Examples: Temporal interval examples

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

Provides examples of working with temporal intervals in Ibis. This includes creating and manipulating intervals for time-based calculations.

```python
import ibis

t = ibis.table("t", schema=dict(start=ibis.schema.timestamp, end=ibis.schema.timestamp))

t.mutate(duration=t.end - t.start)

```

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

### 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
```
```
Tokens:
Raw