---
title: "Iceberg Catalog Comparison: Unity, Polaris, Horizon, and Glue | Dawiso"
description: "Compare Iceberg catalogs: Unity Catalog, Apache Polaris, Snowflake Horizon and AWS Glue on the REST spec, read and write access, credential vending and lock-in."
url: "https://www.dawiso.com/glossary/iceberg-catalog-comparison"
language: "en"
---

November 16, 2026

iceberg catalog comparisoniceberg rest catalogApache PolarisSnowflake Horizon CatalogAWS Glue Data CatalogApache IcebergDatabricks Unity Catalog

# Iceberg Catalog Comparison: Unity Catalog, Apache Polaris, Snowflake Horizon, and AWS Glue

An **Iceberg catalog** is the service that tells every engine where the current version of an Apache Iceberg table lives and decides who may change it. Since most catalogs now speak the same Iceberg REST protocol, the choice is no longer about which engines can connect at all. It is about who can write, how storage credentials are handed out, which policies survive outside the vendor's own engine, and how hard it is to leave.

This guide compares the four catalogs most teams shortlist in 2026, **Databricks Unity Catalog**, **Apache Polaris**, **Snowflake Horizon Catalog** and the **AWS Glue Data Catalog**, plus a short note on Nessie and Lakekeeper. Feature details come from each vendor's documentation as read on 16 November 2026. For the table format itself and a first overview of catalog types, start with [Apache Iceberg catalogs and metadata integration](https://www.dawiso.com/glossary/apache-iceberg#catalog-integration).

TL;DR

All four catalogs implement the **Iceberg REST Catalog API**, so Spark, Trino, Flink, DuckDB and other engines can reach each of them. The differences are in the details. **Unity Catalog** lets external engines write only to its managed Iceberg tables and will not vend credentials for tables with row filters or column masks. **Apache Polaris**, a top-level Apache project since February 2026, is the vendor-neutral option you run yourself or buy as a managed service. **Snowflake Horizon** lets external engines read and write Snowflake-managed Iceberg tables and can enforce masking and row access policies through its Scan Plan API. **AWS Glue** ties every request to IAM and Lake Formation. Pick the catalog that sits closest to where your writes and policies live, and keep business context in a layer that spans all of them.

## What Is an Iceberg Catalog?

An Iceberg table is a set of data files plus a tree of metadata files: a table metadata file, manifest lists and manifests. Each commit writes a new metadata file. The catalog stores one thing that matters more than anything else, the **pointer to the current metadata file**, and it swaps that pointer atomically when a writer commits. That swap is what gives Iceberg its ACID guarantees across engines that never talk to each other.

Over time catalogs have taken on more jobs than the pointer. A modern Iceberg catalog also organizes tables into namespaces, authenticates engines, checks privileges, hands out short-lived storage credentials and records an audit trail. That is why the choice of catalog has become a governance decision as much as an engineering one, and why the [data catalog](https://www.dawiso.com/glossary/data-catalog) your business users browse is usually a different product from the Iceberg catalog your engines commit to.

## The Iceberg REST Catalog Spec

The [Iceberg REST Catalog spec](https://iceberg.apache.org/rest-catalog-spec/) is an OpenAPI definition maintained in the Apache Iceberg project. Instead of every engine shipping a client for every catalog (Hive, Glue, JDBC, Nessie), an engine implements one HTTP client and any compliant catalog can serve it. The [OpenAPI file](https://github.com/apache/iceberg/blob/main/open-api/rest-catalog-open-api.yaml) defines the core operations:

- **`GET /v1/config`**, which every client calls first to get catalog configuration.
- **`loadTable`**, which returns the table's current metadata location and, optionally, storage credentials.
- **`updateTable`**, the commit, plus a multi-table `transactions/commit` for atomic changes across tables.
- **`loadCredentials`**, which returns vended credentials for a table, and **`signRequest`**, which signs object storage requests on the client's behalf.

The `X-Iceberg-Access-Delegation` header is where security enters the protocol. A client sends `vended-credentials` or `remote-signing` to say how it can receive delegated access to storage. With vended credentials, the catalog returns temporary credentials scoped to the table, so the engine never needs a long-lived key to the whole bucket. With remote signing, the catalog signs each storage request itself. Both let the catalog, not the engine's own cloud role, decide which files an engine can touch.

The spec standardizes the protocol, not the policy model. It says nothing about row filters, column masks or how privileges are expressed. Each catalog fills that gap in its own way, and that is where most of the differences below come from.

## Iceberg Catalog Comparison Table

All four catalogs implement the Iceberg REST Catalog API, so the tables compare what differs: what external engines, meaning engines other than the vendor's own, are allowed to do, and who runs and pays for the catalog. Statuses change quickly, so treat them as a snapshot from November 2026 and check the linked documentation before you commit.

| Catalog | External engines can write | Credential vending |
| --- | --- | --- |
| Unity Catalog | Managed Iceberg tables only; foreign Iceberg and Delta tables with Iceberg reads are read-only | Yes, with the EXTERNAL USE SCHEMA privilege; not for tables with row filters or column masks |
| Apache Polaris | Tables in internal catalogs; external catalogs are read-only | Yes, tied to the TABLE_READ_DATA and TABLE_WRITE_DATA privileges |
| Snowflake Horizon | Snowflake-managed Iceberg v2 and v3 tables | Yes; off by default for externally managed tables |
| AWS Glue | Iceberg v1 and v2 tables, through CreateTable and UpdateTable | Yes, bounded by the IAM role and Lake Formation grants |

| Catalog | Policies for external engines | Operator and cost |
| --- | --- | --- |
| Unity Catalog | Enforced on Databricks compute; protected tables are not vended | Databricks; included with Databricks, compute billed as usual (open-source server available separately) |
| Apache Polaris | Role-based privileges on catalogs, namespaces, tables and views | You, or a managed service such as Snowflake Open Catalog; the software is free, you pay to run it |
| Snowflake Horizon | Masking and row access policies through the Spark connector or the Scan Plan API | Snowflake; 0.5 credits per million API calls, billing scheduled for the second half of 2026 |
| AWS Glue | Lake Formation permissions checked on every request | AWS; first million objects and requests free, then $1 per 100,000 objects per month |

The pattern is that every catalog is open at the protocol level and opinionated at the policy level. External engines get the broadest rights on tables the catalog fully owns, and the strongest protections stay inside the vendor's own compute.

## Unity Catalog as an Iceberg Catalog

[Databricks Unity Catalog](https://www.dawiso.com/glossary/databricks-unity-catalog) exposes an [Iceberg REST Catalog API](https://docs.databricks.com/aws/en/external-access/iceberg), at `/api/2.1/unity-catalog/iceberg-rest`, that lets external engines read from and write to Iceberg tables registered in Unity Catalog. What an engine may do depends on the table type:

- **Managed Iceberg tables**, created with `USING iceberg` and now part of Databricks' [default and recommended](https://docs.databricks.com/aws/en/tables/managed) managed table type: read, write and create.
- **Delta tables with Iceberg reads enabled** (the feature also known as UniForm): read-only through the Iceberg endpoint.
- **Foreign Iceberg tables**, federated from another catalog: read-only, no credential vending, and they need a manual refresh to pick up changes.

To use the endpoint, a metastore admin enables external data access and the connecting principal needs `EXTERNAL USE SCHEMA` on the schema. Databricks lists some limits for external writers: they cannot run table maintenance, and equality delete files are rejected. The [credential vending](https://docs.databricks.com/aws/en/external-access/credential-vending) page adds an important governance detail: tables with row filters or column masks are not vended to external clients, and neither are views. In practice, Unity Catalog's fine-grained policies are enforced where Databricks compute runs, and protected data stays there.

Unity Catalog also reaches out. [Catalog federation](https://docs.databricks.com/aws/en/query-federation/catalog-federation) mirrors other catalogs as read-only foreign catalogs, with documented sources including Hive metastores, AWS Glue and Snowflake. The open-source [Unity Catalog server](https://github.com/unitycatalog/unitycatalog/releases) is a separate implementation hosted by LF AI & Data and still pre-1.0 (release 0.7.0 at the time of writing). Most of what this section describes is documented for the Databricks-managed service, not the open-source server. For the cost side, see [Unity Catalog pricing](https://www.dawiso.com/glossary/unity-catalog-pricing).

## Apache Polaris and Snowflake Open Catalog

**Apache Polaris** is an open-source catalog for Apache Iceberg that implements the REST Catalog spec. Snowflake open-sourced it in 2024 and donated it to the Apache Software Foundation, where it entered the Incubator in August 2024. The ASF board [established Polaris as a top-level project](https://www.apache.org/foundation/board/minutes/Polaris.html) on 18 February 2026, and the project [announced its graduation](https://polaris.apache.org/blog/2026/02/19/apache-polaris-graduates-to-top-level-project/) the next day. Releases have been frequent since then; the latest on [GitHub](https://github.com/apache/polaris/releases) is 1.9.0, published on 14 November 2026.

Polaris has the most explicit security model of the four. Its [access control](https://polaris.apache.org/in-dev/unreleased/managing-security/access-control/) grants privileges to **catalog roles**, grants catalog roles to **principal roles**, and grants principal roles to service principals. Table privileges such as `TABLE_READ_DATA` and `TABLE_WRITE_DATA` directly control whether Polaris vends storage credentials for reading or writing. Polaris distinguishes **internal catalogs**, which it manages and engines can write to, from **external catalogs**, which another catalog manages and which are read-only in Polaris. Its [federation](https://polaris.apache.org/in-dev/unreleased/federation/) guides cover Iceberg REST, Hive Metastore, Hadoop and BigQuery Metastore sources. Non-Iceberg formats such as Delta are handled as [generic tables](https://polaris.apache.org/in-dev/unreleased/generic-table/), a beta feature that does not support credential vending.

You can run Polaris yourself or buy it managed. [Snowflake Open Catalog](https://docs.snowflake.com/en/user-guide/opencatalog/overview) is Snowflake's managed service for Apache Polaris, but Snowflake now says new customers cannot create a first Open Catalog account and should use Snowflake Horizon Catalog instead. If you want Polaris without Snowflake, plan for self-hosting or another provider.

## Snowflake Horizon Catalog for Iceberg

Snowflake Horizon Catalog now exposes its own [Iceberg REST Catalog endpoint](https://docs.snowflake.com/en/user-guide/tables-iceberg-query-using-external-query-engine-snowflake-horizon). External engines such as Spark, Flink, Trino, Dremio, DuckDB and PyIceberg can read and write **Snowflake-managed Iceberg tables**, including Iceberg v2 and v3 tables, with vended credentials. Snowflake documents that externally managed Iceberg tables can be [reached through the same endpoint](https://docs.snowflake.com/en/user-guide/externally-managed-iceberg-tables-access-horizon-irc), with vended credentials disabled by default for them.

Horizon's distinctive feature is policy enforcement for external engines. Snowflake describes two ways to apply [masking and row access policies](https://docs.snowflake.com/en/user-guide/tables-iceberg-query-using-external-query-engine-snowflake-horizon-enforce-access-policies) outside Snowflake: the Snowflake Connector for Spark, which works only with Spark, and the Iceberg REST Scan Plan API, which works with any engine on Iceberg SDK 1.11 or later. Snowflake is clear about the limit: an engine that reads table files directly cannot evaluate those policies. Without either method, access is role-based at the table level.

In the other direction, a [catalog-linked database](https://docs.snowflake.com/en/user-guide/tables-iceberg-catalog-linked-database) connects Snowflake to a remote Iceberg REST catalog, so Snowflake can read tables and create Iceberg tables there. Snowflake's documentation walks through Unity Catalog and AWS Glue as remote catalogs. The Horizon endpoint is billed at 0.5 credits per million API calls plus cross-region egress, with billing scheduled to begin in the second half of 2026, subject to change.

## AWS Glue Data Catalog for Iceberg

The AWS Glue Data Catalog has long been the default Iceberg catalog on AWS through Iceberg's native Glue client. It now also serves an [Iceberg REST endpoint](https://docs.aws.amazon.com/glue/latest/dg/connect-glu-iceberg-rest.html) that supports operations including LoadTable, CreateTable and UpdateTable for Iceberg v1 and v2 tables, stored in regular S3 buckets or in S3 Tables. AWS SDKs and native analytics engines authenticate with SigV4, and third-party engines can use OAuth 2.0 tokens.

Glue's governance runs through [AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html), which offers column, row and cell-level controls. AWS states that Glue enforces Lake Formation permissions on every request to the REST endpoint, and that the S3 credentials it vends on LoadTable are bounded by the assumed IAM role and its Lake Formation grants. How much row and cell filtering a third-party engine honors still depends on that engine, so test the exact engine and access pattern you plan to use.

Glue is the cheapest option to start with: per the [Glue pricing page](https://aws.amazon.com/glue/pricing/), the first million objects stored and the first million requests each month are free, and storage above that costs $1 per 100,000 objects per month. Its scope is AWS. If your engines and storage live mostly in AWS, that is an advantage; if they span clouds, it becomes the main constraint.

## Do Nessie and Lakekeeper Still Matter?

**Project Nessie** is still active, with release 0.110.0 published on 6 November 2026 per its [release notes](https://projectnessie.org/releases/). Its distinctive feature remains Git-like branches and tags across many tables, which no catalog above offers in the same form. It suits teams that want isolated branches for testing pipeline changes before merging them, and it is a niche choice for teams that do not.

**Lakekeeper** is an Iceberg REST catalog written in Rust and released under the Apache License, maintained by Vakamo, which also sells a commercial tier. The [project documentation](https://docs.lakekeeper.io/) lists v0.15.1 as the latest release, from 15 November 2026. It is a reasonable candidate for teams that want a lightweight, self-hosted REST catalog and are comfortable with a pre-1.0 project. Both matter mainly as self-hosted alternatives to Polaris rather than as replacements for a platform catalog.

## Credential Vending Compared

Credential vending decides whether an engine needs its own broad access to your storage. Without it, every engine that queries a table needs a cloud role that can read the whole bucket, and the catalog's privileges become advisory. With it, the catalog issues short-lived credentials scoped to the table, and revoking a privilege in the catalog actually cuts off access.

- **Unity Catalog** vends read, write and create credentials for managed Iceberg tables and for Delta tables, after `EXTERNAL USE SCHEMA` is granted. Tables protected by row filters or column masks are excluded, so those can only be queried through Databricks.
- **Apache Polaris** vends credentials during query execution and ties them to `TABLE_READ_DATA` and `TABLE_WRITE_DATA`, which makes the privilege model and the storage access the same thing.
- **Snowflake Horizon** vends credentials for Snowflake-managed tables and, when enabled, for externally managed ones. Masked or row-filtered data needs the Scan Plan API or the Spark connector rather than raw file access.
- **AWS Glue** vends S3 credentials bounded by IAM and Lake Formation, which keeps the AWS permission model intact but makes that model the one you have to manage.

Support also varies by engine. Databricks notes that credential vending support varies by external client, and the same is true across the other catalogs. Test the engines you actually run, not only the catalog.

## Governance Scope of Each Iceberg Catalog

Each catalog governs its own tables well and the wider estate partially. Unity Catalog governs what is registered in a Databricks account and enforces its strongest controls on Databricks compute. Horizon governs Snowflake-managed tables and extends masking and row policies to external engines that use its Scan Plan API. Glue governs the AWS data lake through Lake Formation. Polaris governs whatever you register in it, with role-based privileges and no row or column policy model of its own.

None of them is designed to be the place where a business definition, an owner or an approval lives for data in every platform. A Polaris catalog does not know which Power BI report reads a table; Unity Catalog lineage covers what runs on Databricks. That is not a flaw in any of them. It is the difference between a catalog that engines commit to and a catalog that people use to find, understand and request data, a distinction covered in [the metadata lakehouse](https://www.dawiso.com/glossary/metadata-lakehouse) and [data lakehouse](https://www.dawiso.com/glossary/data-lakehouse) guides.

## Iceberg Catalog Lock-In

Iceberg removes most format lock-in: the data files and metadata sit in your own bucket, in an open format. Catalog lock-in is subtler and comes from four places.

- **Write ownership.** Only one catalog can own commits to a table. Federation in Unity Catalog, Polaris and Snowflake is read-only for foreign tables, so the catalog that owns writes is the one your pipelines depend on.
- **Policies.** Grants, row filters and masks are stored in each catalog's own model. Moving catalogs means re-creating them, and none of the four exports policies in a portable format.
- **Managed-table features.** Automatic maintenance and optimization of managed tables are tied to the platform that manages them. External writers to Unity Catalog cannot run table maintenance, for example.
- **Identity.** Principals, roles and service accounts are catalog-specific. Unity Catalog uses Databricks account identities, Glue uses IAM, Horizon uses Snowflake roles, and Polaris uses its own principals.

The practical way to limit lock-in is to keep data in an open format in storage you own, keep each table's writes in one clearly chosen catalog, and keep business metadata such as definitions, owners and classifications outside any single engine's catalog.

## How to Choose an Iceberg Catalog

- **Most of your writes run on Databricks:** use Unity Catalog with managed Iceberg tables and let other engines read or write through its REST endpoint. Keep tables that need row filters or masks on Databricks compute.
- **Most of your writes run on Snowflake:** use Horizon Catalog with Snowflake-managed Iceberg tables. If external engines must see masked data, check that they support the Scan Plan API.
- **You are AWS-native:** use Glue with Lake Formation, especially if Athena, EMR and Redshift are your main engines.
- **You want a catalog no platform vendor controls:** run Apache Polaris, or Lakekeeper if you prefer a smaller footprint, and budget for operating it.
- **You need Git-style branching across tables:** evaluate Nessie.
- **You run several platforms:** pick one write catalog per table, federate for reads, and put business context in a layer that spans every catalog rather than duplicating it in each.

## Where Dawiso Fits

Dawiso is not an Iceberg catalog and does not commit Iceberg tables. It is a [data catalog](https://www.dawiso.com/glossary/data-catalog) for people: the place where definitions, owners and lineage for data across several platforms are documented once. The [Dawiso Databricks connector](https://help.dawiso.com/actual/databricks/) reads Unity Catalog through its system tables and REST API, including catalogs, schemas, tables, views, volumes, functions, ML models, tags, column masks and row filters, with lineage from `system.access.column_lineage`. The [Snowflake connector](https://help.dawiso.com/actual/snowflake/) brings in databases, schemas, tables, views, stages and other Snowflake objects.

On top of that technical metadata, Dawiso adds a [business glossary](https://www.dawiso.com/glossary/business-glossary), [stewardship](https://www.dawiso.com/glossary/data-stewardship) and lineage that can be extended across systems by [defining relations manually or importing them](https://help.dawiso.com/actual/sources-of-data-lineage/). That keeps the meaning of a table the same whichever Iceberg catalog its engines commit to, and it is the part of the stack that does not have to move if the catalog decision changes.

## Conclusion

The Iceberg REST spec made catalogs interchangeable at the protocol level, which is why every major platform now has one. The choice comes down to where writes live, how credentials are vended, which policies external engines can honor and how much you want to operate yourself. Unity Catalog and Horizon are the natural choices inside their platforms, Glue on AWS, and Polaris when neutrality matters most. Whichever you pick, keep business context outside it. For the format itself, see [Apache Iceberg](https://www.dawiso.com/glossary/apache-iceberg), and for the Delta side of the lakehouse, see [Delta Lake](https://www.dawiso.com/glossary/delta-lake).

## Sources

Feature status changes quickly. All sources were read on 16 November 2026.

- Apache Iceberg - [REST Catalog Spec](https://iceberg.apache.org/rest-catalog-spec/) and the [REST catalog OpenAPI definition](https://github.com/apache/iceberg/blob/main/open-api/rest-catalog-open-api.yaml) (config, loadTable, updateTable, loadCredentials, signRequest, X-Iceberg-Access-Delegation).
- Apache Software Foundation - [Board history: Polaris](https://www.apache.org/foundation/board/minutes/Polaris.html) (incubating since 9 August 2024, top-level project 18 February 2026).
- Apache Polaris - [Apache Polaris graduates to Top Level Project](https://polaris.apache.org/blog/2026/02/19/apache-polaris-graduates-to-top-level-project/), 19 February 2026.
- Apache Polaris - [Releases on GitHub](https://github.com/apache/polaris/releases) (1.9.0, 14 November 2026).
- Apache Polaris - [Access control](https://polaris.apache.org/in-dev/unreleased/managing-security/access-control/), [Federation](https://polaris.apache.org/in-dev/unreleased/federation/) and [Generic tables](https://polaris.apache.org/in-dev/unreleased/generic-table/).
- Snowflake - [Snowflake Open Catalog overview](https://docs.snowflake.com/en/user-guide/opencatalog/overview).
- Snowflake - [Query Iceberg tables with an external engine through Snowflake Horizon Catalog](https://docs.snowflake.com/en/user-guide/tables-iceberg-query-using-external-query-engine-snowflake-horizon) (supported engines, vended credentials, billing).
- Snowflake - [Enforce access policies for external engines](https://docs.snowflake.com/en/user-guide/tables-iceberg-query-using-external-query-engine-snowflake-horizon-enforce-access-policies) (Spark connector, Scan Plan API).
- Snowflake - [Access externally managed Iceberg tables through Horizon IRC](https://docs.snowflake.com/en/user-guide/externally-managed-iceberg-tables-access-horizon-irc).
- Snowflake - [Catalog-linked databases](https://docs.snowflake.com/en/user-guide/tables-iceberg-catalog-linked-database).
- Databricks - [Access Databricks tables from Apache Iceberg clients](https://docs.databricks.com/aws/en/external-access/iceberg).
- Databricks - [Unity Catalog credential vending for external system access](https://docs.databricks.com/aws/en/external-access/credential-vending).
- Databricks - [Unity Catalog managed tables for Delta Lake and Apache Iceberg](https://docs.databricks.com/aws/en/tables/managed).
- Databricks - [Catalog federation](https://docs.databricks.com/aws/en/query-federation/catalog-federation) and [Foreign tables](https://docs.databricks.com/aws/en/tables/foreign).
- Unity Catalog (open source) - [Releases on GitHub](https://github.com/unitycatalog/unitycatalog/releases).
- AWS - [Connecting to the Data Catalog using the AWS Glue Iceberg REST endpoint](https://docs.aws.amazon.com/glue/latest/dg/connect-glu-iceberg-rest.html).
- AWS - [What is AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
- AWS - [AWS Glue pricing](https://aws.amazon.com/glue/pricing/) (Data Catalog storage and requests).
- Project Nessie - [Releases](https://projectnessie.org/releases/).
- Lakekeeper - [Documentation](https://docs.lakekeeper.io/).
- Dawiso Help - [Databricks](https://help.dawiso.com/actual/databricks/), [Snowflake](https://help.dawiso.com/actual/snowflake/) and [Sources of data lineage](https://help.dawiso.com/actual/sources-of-data-lineage/).

[See it in action](https://www.dawiso.com/product/data-catalog)

Data & Analytics Catalog

Create a unified view of your data assets and gain insights faster with automated data discovery.

### Table of contents

What Is an Iceberg Catalog?The Iceberg REST Catalog SpecIceberg Catalog Comparison TableUnity Catalog as an Iceberg CatalogApache Polaris and Snowflake Open CatalogSnowflake Horizon Catalog for IcebergAWS Glue Data Catalog for IcebergDo Nessie and Lakekeeper Still Matter?Credential Vending ComparedGovernance Scope of Each Iceberg CatalogIceberg Catalog Lock-InHow to Choose an Iceberg CatalogWhere Dawiso FitsSources

## Related Terms

### [Unity Catalog Pricing: Is It Free and What Does It Cost?](https://www.dawiso.com/glossary/unity-catalog-pricing)

Unity Catalog has no license fee, but it is not quite free: costs land in Premium-tier DBUs, serverless features, system table queries and sharing egress.

Read more →

### [Unity Catalog vs Microsoft Purview](https://www.dawiso.com/glossary/unity-catalog-vs-microsoft-purview)

Unity Catalog vs Microsoft Purview compared: scope, access control, lineage, and pricing, plus how Purview scans Unity Catalog when you run both.

Read more →

### [Context Layer for Snowflake & Horizon Catalog](https://www.dawiso.com/glossary/context-layer-for-snowflake)

A context layer gives Snowflake data the governed business meaning AI needs. Learn how it works with Snowflake Horizon Catalog and Cortex, and what spans beyond Snowflake.

Read more →

### [What Is a Data Lakehouse?](https://www.dawiso.com/glossary/data-lakehouse)

A data lakehouse combines the low-cost storage of a data lake with the query performance and governance capabilities of a data warehouse. Learn how the lakehouse architecture works, who it's for, and what governance it requires.

Read more →

### [Context Layer for Databricks](https://www.dawiso.com/glossary/context-layer-for-databricks)

A context layer gives Databricks data the governed business meaning AI needs. Learn how it works with Unity Catalog and what a cross-platform context layer adds for AI.

Read more →

### [What Is Apache Iceberg?](https://www.dawiso.com/glossary/apache-iceberg)

Apache Iceberg is an open table format for large-scale analytic datasets. It brings ACID transactions, schema evolution, and time travel to data lakehouses. Learn how it compares to Delta Lake and Hudi.

Read more →
