Develop and run code in Snowflake Notebooks¶

Notebook cell basics¶

This section introduces some basic cell operations. When you create a notebook, three example cells are displayed. You can modify those cells or add new ones.

Run cells in Snowflake Notebooks¶

To run Python and SQL cells in Snowflake Notebooks, you can:

• Run a single cell: Choose this option when making frequent code updates.

  • Press CMD + return on a Mac keyboard, or CTRL + Enter on a Windows keyboard.

  • Select , or Run this cell only.

• Run all cells in a notebook in sequential order: Choose this option before presenting or sharing a notebook to ensure that the recipients see the most current information.

  • Press CMD + shift + return on a Mac keyboard, or CTRL + Shift + Enter on a Windows keyboard.

  • Select Run all.

• Run a cell and advance to the next cell: Choose this option to run a cell and move on to the next cell more quickly.

  • Press shift + return on a Mac keyboard, or Shift + Enter on a Windows keyboard.

  • Select the vertical ellipsis (more actions) for a cell, and choose Run cell and advance.

• Run all above: Choose this option when running a cell that references the results of earlier cells.

  • Select the vertical ellipsis (more actions) for a cell, and choose Run all above.

• Run all below: Choose this option when running a cell that later cells depend on. This option runs the current cell and all following cells.

  • Select the vertical ellipsis (more actions) for a cell, and choose Run all below.

When one cell is running, other run requests are queued and will be executed once the actively running cell finishes.

Format text with Markdown¶

To include Markdown in your notebook, add a Markdown cell:

1. Use a keyboard shortcut and select Markdown, or select + Markdown.

2. Select the Edit markdown pencil icon or double click on the cell, and start writing Markdown.

You can type valid Markdown to format a text cell. As you type, the formatted text appears below the Markdown syntax.

To view only the formatted text, select the Done editing checkmark icon.

Markdown basics¶

This section describes basic Markdown syntax to get you started.

Headers

Heading level	Markdown syntax	Example
Top level	# Top-level Header Copy
2nd-level	## 2nd-level Header Copy
3rd-level	### 3rd-level Header Copy

Inline text formatting

Text format	Markdown syntax	Example
Italics	*italicized text* Copy
Bold	**bolded text** Copy
Link	[Link text](url) Copy

Lists

List type	Markdown syntax	Example
Ordered list	1. first item 2. second item 1. Nested first 2. Nested second Copy
Unordered list	- first item - second item - Nested first - Nested second Copy

Code formatting

Language	Markdown syntax	Example
Python	```python import pandas as pd df = pd.DataFrame([1,2,3]) ``` Copy
SQL	```sql SELECT * FROM MYTABLE ``` Copy

Embed images

File type	Markdown syntax	Example
Image	 Copy

For a notebook that demonstrates these Markdown examples, see the Markdown cells (https://github.com/Snowflake-Labs/snowflake-demo-notebooks/blob/main/Visual%20Data%20Stories%20with%20Snowflake%20Notebooks/Visual%20Data%20Stories%20with%20Snowflake%20Notebooks.ipynb) section of the visual data stories notebook.

Understanding cell outputs¶

When you run a Python cell, the notebook displays the following types of output from the cell are displayed in the results:

• Any results written to the console, such as logs, errors, and warnings and output from print() statements.

• DataFrames are automatically printed with Streamlit’s interactive table display (https://docs.streamlit.io/develop/api-reference/data/st.dataframe), st.dataframe().

  • The supported DataFrame display types include pandas DataFrame, Snowpark DataFrames, and Snowpark Tables.

  • For Snowpark, printed DataFrames are evaluated eagerly without the need to run the .show() command. If you prefer not to evaluate the DataFrame eagerly, for example when running the notebook in non-interactive mode, Snowflake recommends removing the DataFrame print statements to speed up the overall runtime of your Snowpark code.

• Visualizations are rendered in outputs. To learn more about visualizing your data, see Visualize data in Snowflake Notebooks.

Additionally, you can access the results of your SQL query in Python and vice versa. See Reference cells and variables in Snowflake Notebooks.

Reference cells and variables in Snowflake Notebooks¶

You can reference the previous cell results in a notebook cell. For example, to reference the result of a SQL cell or the value of a Python variable, see the following tables:

Referencing SQL output in Python cells:

SELECT 'FRIDAY' as SNOWDAY, 0.2 as CHANCE_OF_SNOW
UNION ALL
SELECT 'SATURDAY',0.5
UNION ALL
SELECT 'SUNDAY', 0.9;

snowpark_df = cell1.to_df()

my_df = cell1.to_pandas()

Referencing variables in SQL code:

SELECT * FROM {{cell2}} where PRICE > 500

c = "USA"

SELECT * FROM my_table WHERE COUNTRY = '{{c}}'

column_name = "COUNTRY"

SELECT * FROM my_table WHERE {{column_name}} = 'USA'

Considerations for running notebooks¶

• Notebooks run using caller’s rights. For additional considerations, see Changing the session context for a notebook.

• You can import Python libraries to use in a notebook. For details, see Import Python packages to use in notebooks.

• When referencing objects in SQL cells, you must use fully qualified object names, unless you are referencing object names in a specified database or schema. See Changing the session context for a notebook.

• Notebook drafts are saved every three seconds.

• You can use Git integration to maintain notebook versions.

• You can configure an idle timeout setting to automatically shut down the notebook session once the setting is met. For information, see Idle time and reconnection.

• Notebook cell results are only visible to the user who ran the notebook and are cached across sessions. Reopening a notebook displays past results from the last time the user ran the notebook using Snowsight.

• BEGIN … END (Snowflake Scripting) is not supported in SQL cells. Instead, use the Session.sql().collect() method in a Python cell to run the scripting block. Chain the sql call with a call to collect to immediately execute the SQL query.

  The following code runs a Snowflake scripting block using the session.sql().collect() method:

  from snowflake.snowpark.context import get_active_session
  session = get_active_session()
  code_to_run = """
  BEGIN
      CALL TRANSACTION_ANOMALY_MODEL!DETECT_ANOMALIES(
          INPUT_DATA => SYSTEM$REFERENCE('TABLE', 'ANOMALY_INFERENCE'),
          TIMESTAMP_COLNAME =>'DATE',
          TARGET_COLNAME => 'TRANSACTION_AMOUNT',
          CONFIG_OBJECT => {'prediction_interval': 0.95}
      );
  
      LET x := SQLID;
      CREATE TABLE ANOMALY_PREDICTIONS AS SELECT * FROM TABLE(RESULT_SCAN(:x));
  END;
  """
  data = session.sql(code_to_run).collect(block=True);
  

  Copy