We're excited to announce a new integration between ClickHouse and Google's [Lakehouse Runtime Catalog](https://docs.cloud.google.com/biglake/docs/blms-rest-catalog), enabling direct querying of [Google Cloud Lakehouse Iceberg tables](https://docs.cloud.google.com/biglake/docs/biglake-iceberg-tables-in-bigquery) in ClickHouse via [Apache Iceberg REST Catalog](https://iceberg.apache.org/).

This integration debuts as a beta feature in ClickHouse 26.2 and will be available shortly after in ClickHouse Cloud.

## **Why Iceberg REST Catalog?** {#why_iceberg_rest_catalog}

A common challenge for data teams is making all their data accessible regardless of where it lives. Discovery, governance, and access control need to work across data lakes, warehouses, and operational stores.

Lakehouse Runtime Catalog solves this by providing a centralized catalog for Apache Iceberg tables in Google Cloud. That enables interoperability with any Iceberg-compatible engine: BigQuery, Apache Spark, Trino, and now ClickHouse.

By connecting to the REST Catalog, ClickHouse can discover and query Google Cloud Lakehouse Iceberg tables stored in Cloud Storage with no data movement, no proprietary connectors, and no metadata syncing required. Data engineers can write Google Cloud Lakehouse Iceberg tables with Spark or BigQuery, and analysts can immediately query that same data with ClickHouse for fast, complex analytics. Data can also be loaded into ClickHouse's native format in a single query using this integration!

## **How does the integration work?** {#how_does_the_integration_work}

To use this integration, you need two things:

* A ClickHouse instance (ClickHouse and [ClickHouse local](https://clickhouse.com/docs/operations/utilities/clickhouse-local) supported)  
* A [Google Cloud project](https://cloud.google.com/) with Lakehouse Runtime Catalog enabled

Lakehouse Runtime Catalog tracks the Iceberg metadata for Iceberg tables and exposes it via the Iceberg REST Catalog API at `https://biglake.googleapis.com/iceberg/v1/restcatalog`. ClickHouse connects to this endpoint to discover and query the underlying tables directly.

For authentication, ClickHouse integrates with Google's [Application Default Credentials (ADC)](https://docs.cloud.google.com/docs/authentication/provide-credentials-adc) mechanism.

## **Getting started** {#getting_started}

Deploy ClickHouse on [Google Cloud](https://clickhouse.com/partners/gcp) or use [ClickHouse local](https://clickhouse.com/docs/operations/utilities/clickhouse-local), ensuring you're on version 26.2 or later. Once your instance is ready, follow the steps below to connect to the Lakehouse Runtime Catalog. Read more in the [ClickHouse documentation for Lakehouse Runtime Catalog](https://clickhouse.com/docs/use-cases/data-lake/biglake-catalog).

## **Authentication with Google Application default credentials** {#authentication_with_google_application_default_credentials}

ClickHouse supports Google ADC natively, giving you two options to authenticate with the Lakehouse Runtime Catalog.

### **Option 1: Point to your ADC credentials file**

If you already have Application Default Credentials configured on your machine (e.g. via `gcloud auth application-default login`), you can simply point ClickHouse to the JSON credentials file. This is the easiest approach for local development and testing:

<pre><code type='click-ui' language='sql'>
SET allow_database_iceberg = 1;

CREATE DATABASE Lakehouse_catalog
ENGINE = DataLakeCatalog('https://biglake.googleapis.com/iceberg/v1/restcatalog')
SETTINGS
  catalog_type = 'biglake',
  google_adc_credentials_file = '/path/to/application_default_credentials.json',
  warehouse = 'gs://&lt;bucket_name&gt;/&lt;optional-prefix&gt;';
</code></pre>

ClickHouse reads the `client_id`, `client_secret`, `refresh_token`, and `quota_project_id` directly from the JSON file, so you don't need to specify them individually.

### **Option 2: Provide credentials inline**

For production deployments or environments where a credentials file isn't available, you can provide the OAuth credentials directly in the query settings:

<pre><code type='click-ui' language='sql'>
SET allow_database_iceberg = 1;

CREATE DATABASE Lakehouse_catalog
ENGINE = DataLakeCatalog('https://biglake.googleapis.com/iceberg/v1/restcatalog')
SETTINGS
  catalog_type = 'biglake',
  google_adc_client_id = '&lt;client-id&gt;',
  google_adc_client_secret = '&lt;client-secret&gt;',
  google_adc_refresh_token = '&lt;refresh-token&gt;',
  google_adc_quota_project_id = '&lt;gcp-project-id&gt;',
  warehouse = 'gs://&lt;bucket_name&gt;/&lt;optional-prefix&gt;';
</code></pre>

Both approaches use the same underlying OAuth flow to authenticate with the Iceberg REST Catalog endpoint and authorize access to the data in Cloud Storage.

## **Querying Google Lakehouse Iceberg tables from ClickHouse** {#querying_google_lakehouse_iceberg_tables_from_clickhouse}

Once you've created a connection using either of the authentication methods above, querying your Google Lakehouse Iceberg tables is straightforward.

### **Listing available tables**

List all tables available in the catalog:

<pre><code type='click-ui' language='sql'>
SHOW TABLES FROM Lakehouse_catalog;
</code></pre>

```shell
┌─name─────────────────────────┐
│ public_data.nyc_taxicab      │
│ public_data.nyc_taxicab_2021 │
└──────────────────────────────┘
```

### **Querying tables**

Query any Google Cloud Lakehouse Iceberg table directly:

<pre><code type='click-ui' language='sql'>
SELECT count(*)
FROM Lakehouse_catalog.`public_data.nyc_taxicab`
WHERE vendor_id = 1;
</code></pre>

You can also inspect the full schema:

<pre><code type='click-ui' language='sql'>
SHOW CREATE TABLE Lakehouse_catalog.`public_data.nyc_taxicab`;
</code></pre>

Backticks are required around table names because ClickHouse doesn't support more than one namespace level.

### **Loading data into ClickHouse for faster queries**

For use cases that require repeated, low-latency queries, you can load data from Google Cloud Lakehouse Iceberg tables into a ClickHouse table:

<pre><code type='click-ui' language='sql'>
CREATE TABLE local_taxi_data
(
    `vendor_id` Int64,
    `pickup_datetime` DateTime64(6),
    `dropoff_datetime` DateTime64(6),
    `passenger_count` Int64,
    `trip_distance` Float64,
    `total_amount` Float64,
    `pickup_location_id` Int64,
    `dropoff_location_id` Int64
)
ENGINE = MergeTree
ORDER BY (pickup_datetime, vendor_id);

INSERT INTO local_taxi_data
SELECT
    vendor_id, pickup_datetime, dropoff_datetime,
    passenger_count, trip_distance, total_amount,
    pickup_location_id, dropoff_location_id
FROM lakehouse_catalog.`public_data.nyc_taxicab`;
</code></pre>

You can now query the local_taxi_data directly in ClickHouse native format for low query latency.

## **What's next** {#whats_next}

This release is just the first step toward deeper integration with Google Cloud's data ecosystem.

We're already working on several enhancements for upcoming releases, including:

* **Write support:** Adding support for writing data back to Google Cloud Lakehouse Iceberg tables from ClickHouse.  
* **Enhanced cloud integration:** Introducing a new user interface in ClickHouse Cloud to easily create connections to the Lakehouse Runtime Catalog and query your data directly from the UI.

![](/uploads/lakehouse_apr2026_image1_c9bdbd90df.png)

With ClickHouse and the Lakehouse Runtime Catalog, you can run fast analytics on all of your Google Cloud Lakehouse Iceberg tables in Google Cloud, without moving data, without duplicating it, and without giving up the tools your teams already use.

## **Get started today** {#get_started_today}

Deploy ClickHouse on [Google Cloud](https://clickhouse.com/pricing?plan=scale&provider=gcp&region=gcp-us-central1&hours=8&storageCompressed=false) or use [ClickHouse local](https://clickhouse.com/docs/operations/utilities/clickhouse-local) once your instance is ready, follow the steps below to connect to the Lakehouse Runtime Catalog. Read more in the [ClickHouse documentation for Lakehouse Runtime Catalog](https://clickhouse.com/docs/use-cases/data-lake/biglake-catalog).


Interested in seeing how ClickHouse works on your data? Get started with ClickHouse Cloud in minutes and receive $300 in free credits.

Get started today

We're excited to announce a new integration between ClickHouse and Google's Lakehouse Runtime CatalogCatalog

large_Google Next Blog Banners 1626.jpg

medium_Google Next Blog Banners 1626.jpg

small_Google Next Blog Banners 1626.jpg

thumbnail_Google Next Blog Banners 1626.jpg

Google Next Blog Banners 1626.jpg

ClickHouse integrates with Lakehouse Runtime Catalog

ClickHouse now supports direct querying of Iceberg and Delta Lake formats across major cloud catalogs without requiring data   migration.

large_image4.jpg

medium_image4.jpg

small_image4.jpg

thumbnail_image4.jpg

image4.jpg

ClickHouse is data lake ready

medium_fts_mar2026_image5.png

small_fts_mar2026_image5.png

thumbnail_fts_mar2026_image5.png

fts_mar2026_image5.png

medium_fts_mar2026_image8.png

small_fts_mar2026_image8.png

thumbnail_fts_mar2026_image8.png

fts_mar2026_image8.png

medium_fts_mar2026_image4.png

small_fts_mar2026_image4.png

thumbnail_fts_mar2026_image4.png

fts_mar2026_image4.png

To validate this more broadly, we benchmarked Full-text Search on 50 TB of log data with 59 vCPU and 256GB of RAM in ClickHouse Cloud. In addition to query latency, we measured storage overhead and insert performance. The index introduces additional write cost, with insert throughput reduced by ~50 percent compared to no index. However, the query performance gains are substantial: up to 10 times faster for cold queries, and even greater improvements when data is cached [on local nodes](https://clickhouse.com/blog/building-a-distributed-cache-for-s3). Compared to Bloom filter-based approaches, Full-text Search is typically slightly slower on inserts but delivers multiple times faster performance at query time.

The animation below illustrates the impact on end-to-end query latency across representative workloads.


o11y-fts.mp4


There is also a storage tradeoff. Full-text Search indexes are larger than Bloom filters, and both are larger than having no index at all. The difference is visible when comparing index sizes directly for our Github dataset:

<pre><code type='click-ui' language='sql'>
SELECT
    name,
    type,
    formatReadableSize(data_compressed_bytes) AS compressed_bytes,
    formatReadableSize(data_uncompressed_bytes) AS uncompressed_bytes
FROM system.data_skipping_indices
WHERE (`table` = 'github_events') AND (database = 'github') AND ((name = 'bloom_body') OR (name = 'fts_body'));
</code></pre>

```shell
   ┌─name───────┬─type─────────┬─compressed_bytes─┬─uncompressed_bytes─┐
1. │ fts_body   │ text         │ 215.84 GiB       │ 223.13 GiB         │
2. │ bloom_body │ bloom_filter │ 7.04 GiB         │ 7.24 GiB           │
   └────────────┴──────────────┴──────────────────┴────────────────────┘

2 rows in set. Elapsed: 0.003 sec.
```

That said, in ClickHouse Cloud the cost of storage is often a small fraction of overall infrastructure spend. At approximately $25 per TB per month, even a sizable index is rarely a dominant cost driver for large analytical workloads, with overall compression remaining strong.

For example, if we look at the compression rate for the GitHub table, it is about 9x before considering the text index. This reduces to around 6x when we factor in the text index.

<pre><code type='click-ui' language='sql'>
SELECT
    formatReadableSize(sum(data_compressed_bytes)) AS compressed_size,
    formatReadableSize(sum(data_uncompressed_bytes)) AS un_compressed_size
FROM system.columns
WHERE (`table` = 'github_events') AND (database = 'github');
</code></pre>

```shell
┌─compressed_size─┬─un_compressed_size─┐
│ 477.09 GiB      │ 4.23 TiB           │
└─────────────────┴────────────────────┘

1 row in set. Elapsed: 0.004 sec.
```

There are still open questions for some scenarios, particularly around how the index interacts with node level and distributed caching layers in observability workloads. For this reason, we have not yet made it the default in ClickStack, but we expect to address these considerations and expand default usage in the near future.

## GitSearch - a Full-text Search demo {#gitsearch_a_full_text_search_demo}

The examples above illustrate the mechanics and performance characteristics, but the best way to understand Full-text Search is to try it yourself. To make this easy, we have built an interactive public demo, [GitTrends](https://gittrends.clickhouse.com/), on top of the same GitHub Events dataset.

![](/uploads/fts_mar2026_image7_520bc9d605.png)

In the demo, you can search for any technology term and instantly see how mentions trend over time across all public GitHub repositories.


GitTrends v2.mp4

Users can then drill into specific repositories where that technology appears, analyze how it shows up in issues and pull requests, and explore how interest in a given project evolves. You can even compare multiple technologies side by side, offering a lightweight alternative to tools like Google Trends for understanding activity and momentum within the developer ecosystem.

![](/uploads/fts_mar2026_image1_3870d680a5.png)



![](/uploads/fts_mar2026_image6_9bdf472d6f.png)

All of this is powered by Full-text Search. For those who want to explore the performance differences directly, the UI also allows you to toggle between Full-text Search, Bloom filter based search, and a linear scan, so you can see the impact of each approach in real time.

As in all of our public demos, we'll keep the dataset updated (hourly) so our users can benefit from GitHub analytics for free.

## Conclusion {#conclusion}

We are delighted to announce that Full-text Search in ClickHouse is now generally available and ready for production use. After multiple iterations and significant performance work, including optimizations for object storage in ClickHouse Cloud, we are excited for users to begin benefiting from fast, native text search at scale.

To celebrate the [GA release, we are hosting a webinar](https://clickhouse.com/company/events/202602-EMEA-AMER-Webinar-FullTextSearch) on March 11th with the engineering team, where we will take a deeper dive into the internals, design decisions, and benchmark results behind Full-text Search.

We look forward to seeing how the community applies this powerful new capability across analytics, observability, and beyond, and to hearing the success stories that follow.


large_Text Indices GA ClickHouse Issue 1440.jpg

medium_Text Indices GA ClickHouse Issue 1440.jpg

small_Text Indices GA ClickHouse Issue 1440.jpg

thumbnail_Text Indices GA ClickHouse Issue 1440.jpg

Text Indices GA ClickHouse Issue 1440.jpg

Announcing General Availability of ClickHouse Full-text Search

**San Francisco, CA — November 18, 2025 — ClickHouse Inc.**, the company behind one of the world’s fastest and most popular real-time analytics databases, today announced the availability of a powerful new integration with [Microsoft OneLake](https://learn.microsoft.com/en-us/fabric/onelake/onelake-overview), the unified data lake of Microsoft Fabric.

This integration enables organizations to harness the scale, governance, and simplicity of OneLake with the speed and flexibility of ClickHouse for real-time, large-scale analytical workloads. Learn more in our [technical post](http://www.clickhouse.com/blog/clickhouse-integrates-with-microsoft-onelake).

## Expanding the ClickHouse-Microsoft collaboration

Following the general availability of [ClickHouse Cloud on Microsoft Azure](https://clickhouse.com/blog/clickhouse-cloud-is-now-generally-available-on-microsoft-azure), recent performance enhancements of ClickHouse on Azure Blob Storage, and [a steady series of new capabilities](https://clickhouse.com/blog/a-year-of-clickhouse-cloud-on-azure), this integration with Microsoft OneLake marks the latest milestone in ClickHouse’s growing collaboration with Microsoft.

This initiative reinforces ClickHouse’s commitment to deep interoperability across Microsoft’s data ecosystem. From Azure to Fabric, the goal is to enable real-time analytics within a unified platform for Microsoft customers.

## Improved interoperability between ClickHouse and Microsoft OneLake

Organizations are increasingly unifying their data with a lakehouse architecture, a flexible foundation that supports best-of-breed tools across workloads, from large-scale analytics with ClickHouse to emerging GenAI and AI agent use cases and more. By storing data in open table formats such as Apache Iceberg or Delta Lake, teams ensure accessibility and interoperability across engines, including ClickHouse, so they can always use the right tool for the job.

The ClickHouse integration with OneLake Table APIs exposes Iceberg tables to ClickHouse, allowing users to directly access and analyze their data, facilitating federated and unified analytics across both ClickHouse and Fabric.

Facilitating real-time analytics with ClickHouse

A common challenge for databases is simplifying how data is ingested into the system itself. This new integration gives Fabric customers powerful new options to query critical data in low latency and high concurrency from OneLake with ClickHouse, enabling new workloads such as real-time analytics, operational dashboards, and agent-facing analytics.

“Microsoft OneLake is a very popular data lake solution among our users, and we’ve long wanted to provide a direct integration to enhance their experience, especially by simplifying data movement and analysis. With the introduction of Table APIs in OneLake, we were finally able to do just that. ClickHouse can now natively query data stored in OneLake, giving users seamless access to all their data in OneLake with zero friction,” said Alexey Milovidov, Co-Founder and CTO of ClickHouse.

“For data to be useful, it must be interoperable with a range of tools our customers use every day,” said Dipti Borkar, VP & GM for Microsoft OneLake and Fabric Ecosystem. “Customers can now use ClickHouse on data unified by Microsoft OneLake to deliver on some of the most data-intensive use cases, like real-time observability, cybersecurity & fraud detection and AI.”

## *About ClickHouse*
   
ClickHouse is a fast, open-source columnar database management system built for real-time data processing and analytics at scale. Engineered for high performance, ClickHouse Cloud delivers exceptional query speed and concurrency, making it ideal for applications that demand instant insight from massive volumes of data. As AI agents become increasingly embedded in software and are generating far more frequent and complex queries, ClickHouse brings a high-throughput, low-latency engine, purpose-built to meet this challenge. Trusted by leading companies like Sony, Tesla, Anthropic, Memorial Sloan Kettering, Lyft, and Instacart, ClickHouse helps teams unlock insights and drive smarter decisions with a scalable, efficient, and modern data platform. For more information, visit [clickhouse.com](http://clickhouse.com).  
  

ClickHouse today announced the availability of a powerful new integration with Microsoft OneLake, the unified data lake service within Microsoft Fabric.

large_image1.png

medium_image1.png

small_image1.png

thumbnail_image1.png

image1.png

ClickHouse strengthens collaboration with Microsoft through Microsoft OneLake Integration for Seamless Data Interoperability

We’re excited to announce a new integration between ClickHouse and Microsoft OneLake -  Microsoft Fabric’s unified data lake - powered by the OneLake [Tables APIs](https://learn.microsoft.com/en-us/fabric/onelake/table-apis/iceberg-table-apis-overview) and [Apache Iceberg](https://iceberg.apache.org/).

This integration will debut as a beta feature in ClickHouse 25.11 (November release) and will be available shortly after in ClickHouse Cloud.

With this new integration, ClickHouse now supports direct querying of Iceberg tables in OneLake, eliminating friction and unlocking unified, fast analytics across multiple sources. 

## **Building a Unified Analytics and AI Platform**

A common challenge for organizations and in particular data teams is being able to use all of their data, regardless of where it’s stored for analytics, GenAI and AI agents. Discovery, governance and access controls are critical to successfully delivering on these projects. Making sure they work with all data assets in various data lakes, data warehouses and operational stores is very difficult. 

Microsoft OneLake enables organizations to unify their data into a common store, cataloging and securing it in a single place. They can use [OneLake Shortcuts](https://learn.microsoft.com/en-us/fabric/onelake/onelake-shortcuts) to connect external stores like [Amazon S3](https://learn.microsoft.com/en-us/fabric/onelake/create-s3-shortcut) or [Google Cloud Storage](https://learn.microsoft.com/en-us/fabric/onelake/create-gcs-shortcut) to OneLake, moving data only when it is queried. They can also continuously replicate data from popular databases using native [zero-copy mirroring](https://learn.microsoft.com/en-us/fabric/mirroring/overview) or build their own with [Open Mirroring](https://learn.microsoft.com/en-us/fabric/mirroring/open-mirroring). All of this data is cataloged in the [OneLake catalog](https://learn.microsoft.com/en-us/fabric/governance/onelake-catalog-overview) and secured using [OneLake Security](https://learn.microsoft.com/en-us/fabric/onelake/security/get-started-security) so it can be safely accessed from Microsoft Fabric, [Azure AI Foundry](https://azure.microsoft.com/en-us/products/ai-foundry) and many popular 3rd party engines like ClickHouse.

OneLake’s Iceberg-compatible [Tables APIs](https://learn.microsoft.com/en-us/fabric/onelake/table-apis/iceberg-table-apis-overview) make it possible for ClickHouse to discover and query data in OneLake with minimal configuration. The ease of use and ecosystem interoperability enable a unified analytical platform that combines flexibility and control to empower users to build and deliver analytics and AI projects quickly with all of their data - enterprise, operational, logs, and 3rd party.

## **How does the integration work?** 

To use this new integration, you only need two components:

- A ClickHouse instance (even [ClickHouse local](https://clickhouse.com/docs/operations/utilities/clickhouse-local) will suffice)  
- A [Microsoft Fabric account](https://www.microsoft.com/en-us/microsoft-fabric/getting-started)

Tables can be written into OneLake using Fabric managed engines like [Spark](https://learn.microsoft.com/en-us/fabric/data-engineering/runtime) or [Data Warehouse](https://learn.microsoft.com/en-us/fabric/data-warehouse/) or your tool of choice. You can write tables in either Delta Lake or Apache Iceberg format. OneLake’s format virtualization will automatically convert between formats and keep both in sync at all times, making it easy to bring your engine of choice without converting or migrating your data.

OneLake also exposes an Iceberg REST catalog via OneLake Table APIs, which ClickHouse uses as an interface to discover and query the underlying Iceberg tables directly.

![onelake_image1.png](/uploads/onelake_image1_01d3a18aa2.png)

For security, ClickHouse uses Microsoft Entra ID (formerly Azure Active Directory) to authenticate the user identity with the OneLake Table APIs, ensuring secure and controlled access to data stored in OneLake. Additionally, the same access token received from Entra will be used to allow users the ability to read data from OneLake. Access permissions are managed in Entra as [Service Principals](https://learn.microsoft.com/en-us/entra/identity-platform/app-objects-and-service-principals?tabs=browser) or through Fabric [workspace-level permissions](https://learn.microsoft.com/en-us/fabric/data-engineering/lakehouse-sharing).

## **Getting Started with ClickHouse and OneLake**

Getting started with ClickHouse and OneLake is simple. You can deploy ClickHouse on [Azure](https://clickhouse.com/partners/azure) or directly from the [Azure Marketplace](https://marketplace.microsoft.com/en-us/product/saas/clickhouse.clickhouse_cloud?tab=overview), ensuring you’re using version 25.11. Once your service is deployed, you’ll be able to enable the OneLake integration and run the following queries to access your Iceberg tables directly. Read more in the [ClickHouse documentation for OneLake](https://clickhouse.com/docs/use-cases/data-lake/onelake-catalog).

## **Querying OneLake from ClickHouse**

It is very simple to start querying OneLake using ClickHouse. [Here](http://learn.microsoft.com/en-us/fabric/onelake/table-apis/table-apis-overview#prerequisites), you’ll find a step-by-step guide to obtaining all the information needed to connect ClickHouse to your OneLake Iceberg catalog.

Since this integration is still in beta, you’ll need to also execute the following:

```sql
SET allow_database_iceberg=1
```

### Creating a connection to OneLake

Once the prerequisites are met, you can create a connection to your OneLake Iceberg catalog by running the following command in ClickHouse:

```sql
CREATE DATABASE onelake_catalog   
ENGINE = DataLakeCatalog('https://onelake.table.fabric.microsoft.com/iceberg')   
SETTINGS
  catalog_type = 'onelake',   
  warehouse = 'warehouse_uuid/data_item_uuid',   
  onelake_tenant_id = '<tenant_id>',   
  oauth_server_uri = 'https://login.microsoftonline.com/<tenant_uuid>/oauth2/v2.0/token',   
  auth_scope = 'https://storage.azure.com/.default',   
  onelake_client_id = '<client_id>',   
  onelake_client_secret = '<client_secret>';
```

### Querying OneLake tables

After creating the connection, you can list all the tables available in the catalog:

```sql
SHOW TABLES FROM onelake_catalog;
```

![onelake_image2.png](/uploads/onelake_image2_6dbbc12201.png)


Then, you can query any table directly from ClickHouse:

```sql
SELECT count(*)   
FROM onelake_catalog.`year_2017.green_tripdata_2017`   
WHERE VendorID = 2;
```

![onelake_image3.png](/uploads/onelake_image3_9e0ea8ce49.png)

## **What’s next**

The 25.11 release is just the first step toward deeper integration with the OneLake ecosystem.

We’re already working on several enhancements that will be introduced in upcoming releases, including:

* **General Availability**: Upgrading the feature from beta to GA by improving the overall quality of life, performance, and incorporating user feedback.

* **Write support:** Adding support for writing data back to your Iceberg tables in OneLake.

* **Enhanced cloud integration:** Introducing a new user interface in ClickHouse Cloud to easily create connections to the OneLake catalog and query your data directly from the UI.

![onelake_image4.png](/uploads/onelake_image4_d309e8af1e.png)

With ClickHouse and Microsoft OneLake, customers can leverage their vast data assets, integrated via OneLake native integrations, Shortcuts and Mirroring, to quickly and easily query, perform complex analytics and drive GenAI and AI Agent initiatives with ease. Get started today at [ClickHouse.com](http://clickhouse.com) 


We’re excited to announce a new integration between ClickHouse and Microsoft OneLake, powered by the OneLake Tables APIs and Apache Iceberg.

large_onelake_image0.png

medium_onelake_image0.png

small_onelake_image0.png

thumbnail_onelake_image0.png

onelake_image0.png

ClickHouse integrates with Microsoft OneLake Table APIs

Can open table formats like Iceberg and Delta Lake really power observability at scale, and if not, what is missing today and which innovations could unlock low cost open observability?

Melvyn Peignon

Blog posts by Melvyn Peignon

ClickHouse integrates with Lakehouse Runtime Catalog

ClickHouse is data lake ready

Announcing General Availability of ClickHouse Full-text Search

ClickHouse strengthens collaboration with Microsoft through Microsoft OneLake Integration for Seamless Data Interoperability

ClickHouse integrates with Microsoft OneLake Table APIs

Are open-table-formats + lakehouses the future of observability?