dbt-polars-catalog-snowflake 0.4.0.dev0__tar.gz

dbt_polars_catalog_snowflake-0.4.0.dev0/.gitignore

@@ -0,0 +1,228 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer,
+#   you could uncomment the following to ignore the entire vscode folder
+.vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# uv.lock
+uv.lock
+
+# dbt-polars
+logs/
+test.env
+.claude/
+decisions.md
+test_project*/

dbt_polars_catalog_snowflake-0.4.0.dev0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: dbt-polars-catalog-snowflake
+Version: 0.4.0.dev0
+Summary: Snowflake Horizon Catalog (Iceberg) catalog for dbt-polars
+Project-URL: Homepage, https://github.com/datamindedbe/incubator-dbt-polars
+Project-URL: Repository, https://github.com/datamindedbe/incubator-dbt-polars
+Project-URL: Changelog, https://github.com/datamindedbe/incubator-dbt-polars/releases
+Author-email: Jonas Crevecoeur <jonas.crevecoeur@dataminded.com>
+Maintainer-email: Jonas Crevecoeur <jonas.crevecoeur@dataminded.com>
+License-Expression: Apache-2.0
+Keywords: catalog,dbt,horizon,iceberg,polars,snowflake
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Requires-Python: <3.14,>=3.10
+Requires-Dist: dbt-polars==0.4.0.dev0
+Description-Content-Type: text/markdown
+
+# dbt-polars
+
+dbt-polars integrates the flexibility and performance of Polars with the data governance and lineage capabilities of dbt.
+
+Key features of **dbt-polars**:
+
+* **Run anywhere**: Polars runs on any compute platform, so you’re not locked into an expensive data warehouse.
+* **Flexible**: Available catalogs let you connect to local storage, Iceberg catalogs, Databricks, and more.
+* **Extensible**: Create a custom catalog to fit your unique storage and warehouse needs.
+* **First-class Python models**: Run Python models with the same performance and capabilities as SQL models.
+* **Mix Python and SQL**: Choose the language that best fits the transformation.
+* **dbt-native**: Bring lineage, documentation, and data testing into your workflow.
+* **Ingestion**: Build efficient, incremental API ingestion with Python models and keep the entire pipeline visible in the lineage graph.
+
+## Installation
+
+```bash
+pip install dbt-polars
+```
+
+Extra dependencies are required for cloud and Iceberg backends:
+
+```bash
+pip install 'dbt-polars[azure]'       # Azure Blob Storage
+pip install 'dbt-polars[databricks]'  # Azure Blob Storage
+pip install 'dbt-polars[fabric]'      # Microsoft Fabric Lakehouse
+pip install 'dbt-polars[snowflake]'   # Snowflake (Iceberg tables)
+pip install 'dbt-polars[iceberg]'     # Apache Iceberg (SQLite, REST, Databricks, …)
+```
+
+## Catalogs
+
+dbt-polars uses **catalogs** to define where data is stored. Each catalog maps to a storage backend. You can configure multiple catalogs in a single profile and reference them from your models.
+
+| Catalog | Backend | Status |
+|---|---|---|
+| `local` | Local filesystem | Usable |
+| `iceberg` with SQLite | Iceberg + SQLite metastore | Usable |
+| `iceberg` with REST + Databricks or OneLake | Iceberg REST API (Unity Catalog, Microsoft Fabric OneLake) | Experimental |
+| `iceberg` with other backends | Any pyiceberg-supported backend | Experimental |
+| `azure` | Azure Blob Storage / ADLS Gen2 | Experimental |
+| `databricks` | Unity Catalog REST API + credential vending | Experimental |
+| `fabric` | Microsoft Fabric Lakehouse via OneLake | Experimental |
+| `snowflake` | Snowflake Horizon Catalog (Iceberg REST) | Experimental |
+
+## Quick start
+
+See the [Getting started](https://datamindedbe.github.io/incubator-dbt-polars/demos/getting_started) guide.
+
+A minimal `profiles.yml` for local development is:
+
+```yaml
+my_project:
+  target: dev
+  outputs:
+    dev:
+      type: polars
+      schema: dev
+
+      catalog_type: local
+      root: ./data
+```
+
+## Documentation
+
+- [Getting started](https://datamindedbe.github.io/incubator-dbt-polars/demos/getting_started)
+- [Catalog overview and profile reference](https://datamindedbe.github.io/incubator-dbt-polars/catalog-overview)
+- [Local catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/local)
+- [Azure catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/azure)
+- [Iceberg catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/iceberg)
+- [Databricks catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/databricks)
+- [Fabric catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/fabric)
+- [Snowflake catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/snowflake)
+- [Custom catalogs](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/custom)
+- [Python models and tests](https://datamindedbe.github.io/incubator-dbt-polars/python-models)

dbt_polars_catalog_snowflake-0.4.0.dev0/README.md

@@ -0,0 +1,75 @@
+# dbt-polars
+
+dbt-polars integrates the flexibility and performance of Polars with the data governance and lineage capabilities of dbt.
+
+Key features of **dbt-polars**:
+
+* **Run anywhere**: Polars runs on any compute platform, so you’re not locked into an expensive data warehouse.
+* **Flexible**: Available catalogs let you connect to local storage, Iceberg catalogs, Databricks, and more.
+* **Extensible**: Create a custom catalog to fit your unique storage and warehouse needs.
+* **First-class Python models**: Run Python models with the same performance and capabilities as SQL models.
+* **Mix Python and SQL**: Choose the language that best fits the transformation.
+* **dbt-native**: Bring lineage, documentation, and data testing into your workflow.
+* **Ingestion**: Build efficient, incremental API ingestion with Python models and keep the entire pipeline visible in the lineage graph.
+
+## Installation
+
+```bash
+pip install dbt-polars
+```
+
+Extra dependencies are required for cloud and Iceberg backends:
+
+```bash
+pip install 'dbt-polars[azure]'       # Azure Blob Storage
+pip install 'dbt-polars[databricks]'  # Azure Blob Storage
+pip install 'dbt-polars[fabric]'      # Microsoft Fabric Lakehouse
+pip install 'dbt-polars[snowflake]'   # Snowflake (Iceberg tables)
+pip install 'dbt-polars[iceberg]'     # Apache Iceberg (SQLite, REST, Databricks, …)
+```
+
+## Catalogs
+
+dbt-polars uses **catalogs** to define where data is stored. Each catalog maps to a storage backend. You can configure multiple catalogs in a single profile and reference them from your models.
+
+| Catalog | Backend | Status |
+|---|---|---|
+| `local` | Local filesystem | Usable |
+| `iceberg` with SQLite | Iceberg + SQLite metastore | Usable |
+| `iceberg` with REST + Databricks or OneLake | Iceberg REST API (Unity Catalog, Microsoft Fabric OneLake) | Experimental |
+| `iceberg` with other backends | Any pyiceberg-supported backend | Experimental |
+| `azure` | Azure Blob Storage / ADLS Gen2 | Experimental |
+| `databricks` | Unity Catalog REST API + credential vending | Experimental |
+| `fabric` | Microsoft Fabric Lakehouse via OneLake | Experimental |
+| `snowflake` | Snowflake Horizon Catalog (Iceberg REST) | Experimental |
+
+## Quick start
+
+See the [Getting started](https://datamindedbe.github.io/incubator-dbt-polars/demos/getting_started) guide.
+
+A minimal `profiles.yml` for local development is:
+
+```yaml
+my_project:
+  target: dev
+  outputs:
+    dev:
+      type: polars
+      schema: dev
+
+      catalog_type: local
+      root: ./data
+```
+
+## Documentation
+
+- [Getting started](https://datamindedbe.github.io/incubator-dbt-polars/demos/getting_started)
+- [Catalog overview and profile reference](https://datamindedbe.github.io/incubator-dbt-polars/catalog-overview)
+- [Local catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/local)
+- [Azure catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/azure)
+- [Iceberg catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/iceberg)
+- [Databricks catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/databricks)
+- [Fabric catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/fabric)
+- [Snowflake catalog](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/snowflake)
+- [Custom catalogs](https://datamindedbe.github.io/incubator-dbt-polars/catalogs/custom)
+- [Python models and tests](https://datamindedbe.github.io/incubator-dbt-polars/python-models)

dbt_polars_catalog_snowflake-0.4.0.dev0/dbt_polars_catalog_snowflake/__init__.py

@@ -0,0 +1,14 @@
+from dbt_polars_catalog_snowflake.catalog import (
+    SnowflakeCatalog,
+    SnowflakeCatalogConfig,
+)
+
+config_class = SnowflakeCatalogConfig
+create_catalog = SnowflakeCatalog
+
+__all__ = [
+    "SnowflakeCatalog",
+    "SnowflakeCatalogConfig",
+    "config_class",
+    "create_catalog",
+]

dbt_polars_catalog_snowflake-0.4.0.dev0/dbt_polars_catalog_snowflake/catalog.py

@@ -0,0 +1,74 @@
+from dbt.adapters.polars.catalogs import (
+    CatalogConfig,
+    IcebergCatalog,
+    IcebergCatalogConfig,
+)
+
+HORIZON_URI = "https://{account}.snowflakecomputing.com/polaris/api/catalog"
+
+
+class SnowflakeCatalogConfig(CatalogConfig):
+    """Config for Snowflake-managed Iceberg tables through Horizon Catalog.
+
+    `account` is the `<org>-<account>` identifier, `database_name` the Snowflake
+    database holding the tables and `role` the role to act as. Every
+    other keyword is passed straight through to pyiceberg's REST catalog, so any
+    authentication it supports works, e.g. `credential` for a programmatic
+    access token or `token` for an OAuth access token.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        type: str,
+        schema: str,
+        account: str,
+        database_name: str,
+        role: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        self.name = name
+        self.type = type
+        self.schema = schema
+        self.account = account
+        self.database_name = database_name
+        self.role = role
+        self.pyiceberg_kwargs: dict[str, object] = kwargs
+
+    def iceberg_config(self) -> IcebergCatalogConfig:
+        role_scope = {"scope": f"session:role:{self.role.upper()}"} if self.role else {}
+        return IcebergCatalogConfig(
+            name=self.name,
+            type="iceberg",
+            schema=self.schema,
+            pyiceberg_type="rest",
+            **{
+                "uri": HORIZON_URI.format(account=self.account),
+                "warehouse": self.database_name.upper(),
+                "header.X-Iceberg-Access-Delegation": "vended-credentials",
+                **role_scope,
+                **self.pyiceberg_kwargs,
+            },
+        )
+
+    def unique_field(self) -> str:
+        return f"{self.account}/{self.database_name}"
+
+    def connection_keys(self) -> tuple[str, ...]:
+        return ("name", "account", "database_name", "role")
+
+
+class SnowflakeCatalog(IcebergCatalog):
+    """Snowflake-managed Iceberg tables through Snowflake Horizon Catalog.
+
+    Uses Horizon's Iceberg REST endpoint with credentials vended by Snowflake,
+    so no Snowflake warehouse is needed.
+    """
+
+    config: SnowflakeCatalogConfig  # type: ignore[assignment]
+    min_commit_interval = 2
+
+    def __init__(self, config: SnowflakeCatalogConfig, project_root: str) -> None:
+        super().__init__(config.iceberg_config(), project_root)
+        self.config = config

dbt_polars_catalog_snowflake-0.4.0.dev0/hatch_build.py

@@ -0,0 +1,39 @@
+import sys
+from email.parser import Parser
+from pathlib import Path
+
+from hatchling.metadata.plugin.interface import MetadataHookInterface
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+def core_version(root: Path) -> str:
+    """The dbt-polars version, which every catalog package shares."""
+    pkg_info = root / "PKG-INFO"
+    if pkg_info.exists():
+        return Parser().parsestr(pkg_info.read_text())["Version"]
+    with open(root.parent.parent / "pyproject.toml", "rb") as file:
+        return tomllib.load(file)["project"]["version"]
+
+
+def core_readme(root: Path) -> str:
+    """The dbt-polars README; built from an sdist it's the copy included there."""
+    local = root / "README.md"
+    return (local if local.exists() else root.parent.parent / "README.md").read_text()
+
+
+class CustomMetadataHook(MetadataHookInterface):
+    def update(self, metadata: dict) -> None:
+        version = core_version(Path(self.root))
+        metadata["version"] = version
+        metadata["readme"] = {
+            "content-type": "text/markdown",
+            "text": core_readme(Path(self.root)),
+        }
+        metadata["dependencies"] = [
+            f"dbt-polars=={version}",
+            *self.config.get("dependencies", []),
+        ]

dbt_polars_catalog_snowflake-0.4.0.dev0/pyproject.toml

@@ -0,0 +1,70 @@
+[project]
+name = "dbt-polars-catalog-snowflake"
+dynamic = ["version", "dependencies", "readme"]
+description = "Snowflake Horizon Catalog (Iceberg) catalog for dbt-polars"
+requires-python = ">=3.10, <3.14"
+license = "Apache-2.0"
+keywords = ["dbt", "polars", "catalog", "snowflake", "iceberg", "horizon"]
+authors = [
+  {name = "Jonas Crevecoeur", email = "jonas.crevecoeur@dataminded.com"}
+]
+maintainers = [
+  {name = "Jonas Crevecoeur", email = "jonas.crevecoeur@dataminded.com"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Database",
+]
+
+[project.urls]
+Homepage = "https://github.com/datamindedbe/incubator-dbt-polars"
+Repository = "https://github.com/datamindedbe/incubator-dbt-polars"
+Changelog = "https://github.com/datamindedbe/incubator-dbt-polars/releases"
+
+[build-system]
+requires = ["hatchling", "tomli; python_version < '3.11'"]
+build-backend = "hatchling.build"
+
+# Version, readme and a dbt-polars==<version> pin come from the core project,
+# see hatch_build.py. pyiceberg comes with the core `snowflake` extra.
+[tool.hatch.metadata.hooks.custom]
+dependencies = []
+
+[tool.hatch.build.targets.sdist.force-include]
+"../../README.md" = "README.md"
+
+[tool.uv]
+cache-keys = [
+    { file = "pyproject.toml" },
+    { file = "hatch_build.py" },
+    { file = "../../pyproject.toml" },
+    { file = "../../README.md" },
+]
+
+[tool.uv.sources]
+dbt-polars = { workspace = true }
+
+[tool.ruff]
+extend = "../../pyproject.toml"
+
+[tool.ruff.lint]
+extend-select = ["TID251"]
+
+[tool.ruff.lint.flake8-tidy-imports.banned-api]
+"dbt.adapters.polars.catalogs.baseCatalog".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.catalogs.storageCatalog".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.catalogs.tableFormatCatalog".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.catalogs.formats".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.catalogs.icebergCatalog".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.catalogs.iceberg_write_utils".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.connections".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.impl".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.relation".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.sql_rewrite".msg = "Use the public API from dbt.adapters.polars.catalogs"
+"dbt.adapters.polars.utils".msg = "Use the public API from dbt.adapters.polars.catalogs"

dbt_polars_catalog_snowflake-0.4.0.dev0/tests/test_snowflake_catalog.py

@@ -0,0 +1,145 @@
+import subprocess
+import sys
+from types import SimpleNamespace
+
+import polars as pl
+import pytest
+from dbt.adapters.polars.catalogs import IcebergCatalog, PolarsRelation
+from dbt_common.exceptions import DbtRuntimeError
+
+from dbt_polars_catalog_snowflake import SnowflakeCatalog, SnowflakeCatalogConfig
+
+DATA = pl.DataFrame({"id": [1]})
+
+
+def make_config(**kwargs) -> SnowflakeCatalogConfig:
+    return SnowflakeCatalogConfig(
+        name="snowflake",
+        type="snowflake",
+        schema="analytics",
+        account="myorg-myaccount",
+        database_name="analytics_db",
+        **kwargs,
+    )
+
+
+def make_catalog(**kwargs) -> SnowflakeCatalog:
+    return SnowflakeCatalog(make_config(**kwargs), project_root=".")
+
+
+def relation(**kwargs) -> PolarsRelation:
+    return PolarsRelation.create(
+        database="snowflake",
+        schema="analytics",
+        identifier="orders",
+        catalog="snowflake",
+        **kwargs,
+    )
+
+
+def test_properties_point_to_horizon():
+    properties = make_catalog(role="transformer")._catalog_properties
+
+    assert properties["type"] == "rest"
+    assert properties["uri"] == (
+        "https://myorg-myaccount.snowflakecomputing.com/polaris/api/catalog"
+    )
+    assert properties["warehouse"] == "ANALYTICS_DB"
+    assert properties["scope"] == "session:role:TRANSFORMER"
+    assert properties["header.X-Iceberg-Access-Delegation"] == "vended-credentials"
+
+
+def test_other_profile_keys_go_to_pyiceberg():
+    properties = make_catalog(
+        credential="pat", scope="session:role:OTHER"
+    )._catalog_properties
+
+    assert properties["credential"] == "pat"
+    assert properties["scope"] == "session:role:OTHER"
+
+
+def test_profile_overrides_uri_and_warehouse():
+    properties = make_catalog(
+        uri="https://private.example/polaris/api/catalog", warehouse="OTHER_DB"
+    )._catalog_properties
+
+    assert properties["uri"] == "https://private.example/polaris/api/catalog"
+    assert properties["warehouse"] == "OTHER_DB"
+
+
+def test_names_are_kept_as_in_dbt():
+    pytest.importorskip("pyiceberg")
+    catalog = make_catalog()
+    listed = []
+    catalog._catalog_instance = SimpleNamespace(
+        list_tables=lambda namespace: (
+            listed.append(namespace)
+            or [("Analytics", "MyOrders"), ("Analytics", "customers")]
+        ),
+        list_namespaces=lambda: [("Analytics",), ("raw",)],
+    )
+    schema_relation = PolarsRelation.create(
+        database="snowflake",
+        schema="Analytics",
+        identifier="MyOrders",
+        catalog="snowflake",
+    )
+
+    names = [
+        r.identifier for r in catalog.list_relations_without_caching(schema_relation)
+    ]
+
+    assert catalog._id(schema_relation) == ("Analytics", "MyOrders")
+    assert names == ["MyOrders", "customers"]
+    assert listed == [("Analytics",)]
+    assert catalog.list_schemas() == ["Analytics", "raw"]
+
+
+@pytest.mark.parametrize(
+    "write",
+    [
+        lambda catalog, rel: catalog.write_relation(rel, DATA, []),
+        lambda catalog, rel: catalog.validate_incremental_relation(rel, {}),
+        lambda catalog, rel: catalog.apply_snapshot_delta(rel, DATA, DATA),
+    ],
+)
+def test_writes_reject_file_format(write):
+    with pytest.raises(
+        DbtRuntimeError, match="file_format is not supported for the snowflake catalog"
+    ):
+        write(make_catalog(), relation(file_format="parquet"))
+
+
+def record_iceberg_calls(monkeypatch, method: str, returns=None) -> list[tuple]:
+    """Replace an IcebergCatalog method with one recording its arguments."""
+    calls: list[tuple] = []
+
+    def record(self, *args):
+        calls.append(args)
+        return returns
+
+    monkeypatch.setattr(IcebergCatalog, method, record)
+    return calls
+
+
+def test_column_names_are_written_as_they_are_in_dbt(monkeypatch):
+    calls = record_iceberg_calls(monkeypatch, "write_relation")
+
+    make_catalog().write_relation(
+        relation(), pl.DataFrame({"id": [1], "CustomerName": ["a"]}), ["id"], {}
+    )
+
+    _, data, partition_by, _ = calls[0]
+    assert data.columns == ["id", "CustomerName"]
+    assert partition_by == ["id"]
+
+
+def test_catalog_does_not_import_pyiceberg_until_used():
+    code = (
+        "import sys\n"
+        "from dbt_polars_catalog_snowflake import create_catalog, config_class\n"
+        "create_catalog(config_class(name='s', type='snowflake', schema='s', "
+        "account='o-a', database_name='d'), '.')\n"
+        "assert not [m for m in sys.modules if m.startswith('pyiceberg')]\n"
+    )
+    subprocess.run([sys.executable, "-c", code], check=True)