Free Access Snowflake.SPS-C01.v2026-07-23.q130 Practice Test (Page 14)

Question 61

You are developing a Snowpark application that processes large volumes of JSON data from an external stage. Initial testing on a MEDIUM warehouse results in significant query queuing. You suspect the issue is CPU bound due to complex JSON parsing and UDF execution within Snowpark. Considering only warehouse sizing options and assuming cost is a secondary concern to performance during peak processing hours, which strategy is MOST effective for optimizing performance? Consider the impact on concurrency.

A.Upgrade the warehouse to a LARGE. This provides more CPU and memory for the existing workload, potentially resolving the bottleneck and improving overall throughput.

B.Scale out to multiple MEDIUM warehouses using auto-scaling. This increases concurrency, allowing more queries to run simultaneously, but might not address CPU-bound operations within a single query.

C.Upgrade to an X-LARGE or higher warehouse, leveraging the increased resources to handle complex parsing and UDF execution more efficiently. Monitor CPU utilization after the upgrade.

D.Implement query acceleration using materialized views to pre-compute JSON parsing results. Then, add warehouses as needed for concurrent requests

E.Scale down to a SMALL warehouse. Smaller warehouses are optimized for smaller operations and can process certain types of operations faster. This could improve latency.

Question 62

You are building a Snowpark Python application to perform complex data transformations and want to leverage external packages not pre-installed in the Snowflake environment. You need to ensure these packages are available within your Snowpark session. Which of the following methods are valid for deploying and using these third-party packages within your Snowpark Python environment? (Select TWO)

A.Use the 'session.addDependency()' method to upload individual '.py' files containing the package code directly to the Snowflake internal stage.

B.Create a 'conda' environment file ('environment.yml') specifying the required packages and use the method to upload the environment definition. Snowflake will automatically install the packages within the session's environment.

C.Manually install the packages on the Snowflake compute pool nodes before starting the Snowpark session.

D.Utilize Snowflake's Anaconda channel integration and specify the package names as strings in the method. Snowflake will automatically resolve and install the packages from the Anaconda channel.

E.Deploy the required packages using the SnowCLl package management commands, and then the Snowpark session will be able to automatically use the deployed packages.

Question 63

You have a Snowpark DataFrame containing semi-structured data in a column named 'payload'. The 'payload' column contains JSON objects, and some of these objects contain nested arrays. You need to flatten all arrays, regardless of their level of nesting, and extract specific fields from the flattened data'. What is the MOST efficient approach using Snowpark to achieve this while minimizing the amount of code?

A.Use recursive UDFs to traverse and flatten the JSON structure, then create a new DataFrame from the flattened data.

B.Iteratively apply the 'explode' function to each array field within the 'payload' column, manually identifying and flattening each level of nesting.

C.Convert the DataFrame to an RDD, then use the RDD's 'flatMap' function to flatten the nested arrays before converting back to a DataFrame.

D.Use a single ' SELECT statement with multiple 'LATERAL FLATTEN' calls (using SQL syntax within 'session.sql') to flatten all nested arrays simultaneously.

E.Create a stored procedure in Snowflake that recursively flattens the JSON, then call this stored procedure from Snowpark to transform the DataFrame.

Question 64

You have developed a Snowpark Python stored procedure that calculates the average sales per region from a large sales data table. The procedure is currently defined inline within your Snowflake notebook. You want to operationalize this by creating the stored procedure from a local Python file named The file contains the following code: "'python from snowflake.snowpark.session import Session def calculate_avg_sales(session: Session, sales_table_name: str, region_column: str, sales_column: str) -> float: sales df = session.table(sales table name) avg_sales df = sales_df.group_by(region_column).agg({sales_column: 'avg'}) avg_sales = avg_sales_df.collect() return avg_sales[0][1] Which of the following code snippets correctly creates the stored procedure 'AVG SALES PROC in Snowflake, referencing the Python file, and handles potential dependency issues? Assume you have already established a Snowpark session named 'session' and that the stage 'my_stage' already exists.

Question 65

You have a Snowpark DataFrame containing product information, and you want to persist it into a Snowflake table named PRODUCTS. You need to handle the following scenarios: 1. If the table 'PRODUCTS does not exist, create it. 2. If the table PRODUCTS' exists, append the data from 'df_products' to it. Which of the following methods can achieve this?