Snowflake Python API for Resource Management (snowflake-core)

1.12.0 · active · verified Thu Apr 09

The `snowflake-core` library is a Python API that provides programmatic access to Snowflake entity metadata and allows for interaction with Snowflake resources. It enables users to create, delete, and modify Snowflake objects using Python, offering similar functionality to Snowflake's SQL command API. The library is currently at version 1.12.0 and is actively maintained with regular releases.

Warnings

gotcha Always verify you are consulting the documentation for the latest version of `snowflake-core`. Snowflake's documentation portal might default to older versions, which can lead to confusion regarding available features or API signatures.
Fix: Look for a 'View latest version' link or ensure the URL reflects the current version (e.g., `https://docs.snowflake.com/en/developer-guide/python-apis/` and check the version displayed on the page).
gotcha Understand the distinction between local Python objects (references) and actual Snowflake snapshots. Operations that modify or retrieve information from Snowflake generally require explicit calls through the `Root` object and its collections, as Python objects in memory don't automatically sync with the remote state.
Fix: Consult the official documentation on 'Local references vs Snowflake snapshots' to grasp the interaction model and manage performance and cost expectations.
gotcha Connection parameters are typically sensitive and should be managed securely, preferably using environment variables as shown in official examples. Hardcoding credentials directly in code is discouraged.
Fix: Store Snowflake account, user, password, and other connection details in environment variables (e.g., `SNOWFLAKE_ACCOUNT`, `SNOWFLAKE_USER`, `SNOWFLAKE_PASSWORD`) and retrieve them using `os.environ.get()`.

Install

pip install snowflake-core Install with pip

Imports

Root
```
from snowflake.core import Root
```
The primary entry point for managing Snowflake objects.
connect
```
from snowflake.connector import connect
```
Used to create a SnowflakeConnection object for initializing Root.
Session
```
from snowflake.snowpark import Session
```
Used to create a Snowpark Session object for initializing Root.

Quickstart

This quickstart demonstrates how to initialize the `Root` object, which is the entry point for managing Snowflake resources, using either a `snowflake.connector.connect` object or a `snowflake.snowpark.Session` object. It highlights the use of environment variables for secure connection parameter management.

import os
from snowflake.connector import connect
from snowflake.snowpark import Session
from snowflake.core import Root

# Option 1: Create Root instance from Snowflake Connection
connection_params = {
    "account": os.environ.get("SNOWFLAKE_ACCOUNT", ""),
    "user": os.environ.get("SNOWFLAKE_USER", ""),
    "password": os.environ.get("SNOWFLAKE_PASSWORD", ""),
    "database": os.environ.get("SNOWFLAKE_DATABASE", "test_db"),
    "warehouse": os.environ.get("SNOWFLAKE_WAREHOUSE", "test_wh"),
    "schema": os.environ.get("SNOWFLAKE_SCHEMA", "public"),
}

# Ensure required environment variables are set
if not all(connection_params.values()):
    print("Warning: Some Snowflake connection parameters are missing. Please set SNOWFLAKE_ACCOUNT, SNOWFLAKE_USER, and SNOWFLAKE_PASSWORD environment variables.")
    # Exit or handle error if connection is critical

try:
    # Using snowflake.connector
    connection = connect(**connection_params)
    root_from_conn = Root(connection)
    print(f"Root instance created from SnowflakeConnection: {root_from_conn}")

    # Example: Accessing a database collection
    # Assuming 'mydatabase' exists or will be created
    # my_database = root_from_conn.databases["MYDATABASE"]
    # print(f"Accessed database: {my_database}")

    connection.close()

    # Option 2: Create Root instance from Snowpark Session
    # Ensure required environment variables are set for Snowpark as well if different
    session = Session.builder.configs(connection_params).create()
    root_from_session = Root(session)
    print(f"Root instance created from Snowpark Session: {root_from_session}")

    # Example: Accessing a compute pool collection
    # compute_pools = root_from_session.compute_pools
    # print(f"Accessed compute pools collection: {compute_pools}")

    session.close()

except Exception as e:
    print(f"An error occurred during quickstart: {e}")

view raw JSON →