> This page is for Structured Data Models Client.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/sdgm/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/sdgm/_mcp/server.

# Snowflake Connector

> Connect Kumo Relational to data stored in Snowflake

There are two ways to use Snowflake data: sample it in place with `SnowflakeSource`, or read a table into memory with `read()` and build the schema from DataFrames. Prefer `SnowflakeSource` for warehouse-sized tables — `materialize()` queries only the rows a prediction needs, rather than reading a whole table. (Building the schema itself still runs lightweight metadata and preview queries — see [Build a Schema](/sdgm/kumo-relational/user-guide/build-a-relational-graph/graph-creation#schemas-over-tables-that-stay-in-place).)

## Installation

```bash
pip install "structured-data-models-client[relational,snowflake]"
```

## Sample in place with `SnowflakeSource`

```python
import snowflake.connector
from sdm_client import PredictiveQuery, Schema
from sdm_connectors import SnowflakeSource

connection = snowflake.connector.connect(
    account="my_account", user="my_user", password="...", warehouse="my_warehouse",
)
source = SnowflakeSource(connection, database="MY_DATABASE", schema="MY_SCHEMA")

schema = Schema.from_source(
    source,
    {"users": "USERS", "orders": "ORDERS"},
    time_columns={"orders": "ORDER_TIME"},
)
request = PredictiveQuery(
    "PREDICT COUNT(orders.*, 0, 30, days) FOR EACH users.USER_ID", schema
).materialize(indices=[7, 12, 3])
```

`tables` maps the *table* names your query uses to the names in Snowflake — `{"users": "USERS"}` lets you write `users` in PQL for Snowflake's `USERS` table. **Column names are not renamed** and PQL matches them case-sensitively, so if Snowflake reports a column as `USER_ID` (the default for an unquoted identifier), reference it as `users.USER_ID`, not `users.user_id`. Quote the identifier in PQL if you need a different case: `` users.`user_id` ``.

The connection is yours — `SnowflakeSource` never closes it; close it when you are done sampling. A Snowpark `session` works too; it is reached through its own connector connection.

Columns, keys, and relationships come from Snowflake's own constraints where it declares any, and from the same name-matching inference as `Schema.from_data()` otherwise. Because Snowflake does not enforce a declared key, each key is checked against every row with one aggregate query per table; pass `check_keys=False` to skip that when the key is already trusted.

## Snowflake semantic views

A Snowflake semantic view already states its tables, joins, and columns. Convert it directly:

```python
schema = Schema.from_source(source.semantic_model("sales_metrics"))
```

Its expressions run as SQL under your own credentials, so by default only pure, deterministic built-in functions are allowed; pass `trust_expressions=True` on `semantic_model(...)` to keep an expression that calls something else, when you trust whoever wrote the view. `schema.conversion_notes` lists what the conversion resolved, for a person to read — its wording is not part of the contract.

## Read into memory instead

```python
from sdm_connectors import read
from sdm_client import Schema

users = read(
    "snowflake",
    account="my_account", user="my_user", password="...", warehouse="my_warehouse",
    table="USERS",
)
orders = read("snowflake", account="my_account", user="my_user", password="...", warehouse="my_warehouse", table="ORDERS")

schema = Schema.from_data({"users": users, "orders": orders})
```

Use a secret manager or environment variable for credentials; do not store passwords in source files or notebooks. In a Snowflake notebook with an active Snowpark session, omit authentication arguments and `read()` reuses that session.

Review the inferred schema and relationships before predicting — see [Build a Schema](/sdgm/kumo-relational/user-guide/build-a-relational-graph/graph-creation).