Free Snowflake SPS-C01 Exam Dumps Questions & Answers

You have a requirement to process a large number of JSON files stored in a Snowflake stage 'json_stage'. These JSON files contain complex nested structures. You need to extract specific fields from these files using Snowpark Python and load them into a Snowflake table. You want to use 'SnowflakeFile' to read the JSON files and minimize the amount of data loaded into memory. Select all that apply from the following options to efficiently accomplish this task:

• A.Use to directly load all JSON files into a Snowpark DataFrame and then use 'select' with path expressions (e.g., 'col('fieldl .nested_field')) to extract the required fields.
• B.Create a UDF that accepts a 'SnowflakeFile' object, opens the file, reads the JSON data using 'json.load', extracts the required fields, and returns a JSON string. Create a Snowpark DataFrame using 'session.read.option('PATTERN', ' then call the UDF with the file path, and finally parse the returned JSON string to load data.
• C.Create a UDF that takes a file path as input, constructs a 'SnowflakeFile' object within the UDF, reads the JSON data using 'json.loadS, extracts the required fields, and returns a Row object or a dictionary. Use 'session.sql('SELECT relative_path FROM to get file paths, create Snowpark Dataframe and then call the UDF on each file path.
• D.Write a Python script that downloads all JSON files from the stage using 'SnowflakeFile.get' , iterates through the downloaded files, parses each file, extracts the fields, and inserts the data into the Snowflake table using the Snowflake Python connector.
• E.Create a UDTF that accepts a "SnowflakeFile' object, uses 'json.loadS to parse the JSON content incrementally, extracts the desired fields, and yields rows for insertion into the target table. Use 'session.read.option('PATTERN', ' to generate the initial DataFrame.

You have configured your Snowpark application to use a '.env' file for storing connection parameters. The ' .env' file contains the following:

Which of the following code snippets demonstrates the most secure and recommended method for creating a Snowpark session using these environment variables and also ensuring the file exists?

• A.
• B.
• C.
• D.
• E.

A Snowpark application connects to Snowflake using key pair authentication. After several successful executions, the application starts failing with authentication errors. You suspect an issue with the private key. Considering best practices for security and troubleshooting, which of the following actions should you take FIRST to diagnose and resolve the problem?

• A.Restart the Snowpark application server to refresh the session and clear any cached credentials.
• B.Check the Snowflake login history in ACCOUNT _ USAGE view to identify the specific error message and the IP address from which the failed login attempts originated. Use new authtype and password.
• C.Immediately revoke the user's access to Snowflake and create a new user with a different private key.
• D.Rotate the public/private key pair immediately and update the Snowpark application with the new private key. Generate new username and password.
• E.Verify that the private key file exists at the specified path in the Snowpark application configuration and that the user running the application has read permissions on the file.

A data scientist has developed a Snowpark Python stored procedure named 'model_training'. This procedure utilizes a large machine learning model and requires significant compute resources. The data scientist wants to optimize the cost and performance of running this stored procedure. Which of the following strategies would be the MOST effective for achieving this goal?

• A.Specify a warehouse size using the 'warehouse' parameter within the '@sproc' decorator and leverage auto-suspend and auto-resume features to minimize costs when the procedure is idle.
• B.Convert the Python stored procedure to a SQL stored procedure to leverage Snowflake's SQL optimization engine.
• C.Register the stored procedure with the '@sproc' decorator without specifying any warehouse size, letting Snowflake automatically manage the warehouse.
• D.Split the stored procedure into multiple smaller procedures and execute them sequentially on a smaller warehouse.
• E.Run the stored procedure on a larger Snowflake warehouse to reduce execution time, regardless of potential idle time.

You have a Snowpark DataFrame named 'transactions' containing transaction data'. You need to create a UDTF using Python to categorize transactions into 'High Value', 'Medium Value', and 'Low Value' based on the transaction amount and the customer's region. The categorization logic requires access to a dynamically updated lookup table stored in a Snowflake stage. Which approach would be MOST efficient and scalable, minimizing data transfer and maximizing Snowpark's vectorized operations?

• A.Create a vectorized UDTF that loads the lookup table into memory during the first call, and then caches it for subsequent calls. Implement a refresh mechanism using a Snowflake external function triggered by stage updates.
• B.Create a vectorized UDF. Load the lookup table from the stage into the UDF's environment once during initialization. Then, process transactions in batches using pandas DataFrames within the UDF.
• C.Use a UDTF with the parameter, reading the lookup table directly into the UDTF using a Snowpark DataFrame and joining it with each batch of the 'transactions DataFrame. Materialize the result to a temporary table.
• D.Define a scalar UDF that queries the lookup table directly from Snowflake using a Snowflake connector. This avoids data transfer to the UDF but introduces external dependency and connection management overhead for each row.
• E.Use a scalar UDF, reading the lookup table from the stage for each transaction. This ensures data consistency but may incur significant overhead for each row processed.