Snowflake Certified SnowPro Specialty - Snowpark : SPS-C01 Exam

You have created a Python UDTF in Snowpark to process large volumes of image data'. This UDTF resizes each image and extracts certain features from it. The process is memory-intensive and sometimes fails due to Python process exceeding memory limits. You need to optimize this UDTF for memory usage. Which of the following strategies would be MOST effective? (Select TWO)

• A. Use a scalar UDF instead of a UDTF. Scalar UDFs are generally more memory efficient.
• B. Increase the value of 'MAX BATCH SIZE in the Snowpark session configuration to allow the UDTF to process larger batches of images at once.
• C. Utilize a smaller Snowflake warehouse size. Smaller warehouses have less memory per node, which will force the UDTF to process data in smaller chunks.
• D. Implement lazy evaluation and iterators within the UDTF to process images one at a time instead of loading all images into memory at once.
• E. Leverage external packages such as PILIPillow with appropriate image compression techniques to reduce the memory footprint of each image before processing.

Consider a Snowpark DataFrame with columns 'DEPARTMENT, 'SALARY , and 'YEAR. You want to find the average salary for each department over all years and then filter the departments to only include those where the average salary is greater than 100000. Which of the following approaches is the MOST efficient and correct way to achieve this using Snowpark Python?

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

You are developing a Snowpark stored procedure in Python to perform sentiment analysis on customer reviews. The procedure relies on a custom Python library, 'sentiment_analyzer.py' , which is not available in Snowflake's default Anaconda channel. You also need to include the 'nltk' library. Which of the following approaches is the MOST efficient and recommended way to make both dependencies available to your stored procedure within Snowflake?

• A. Upload 'sentiment_analyzer.py' and 'nltk"s compiled code as separate stages, then import them within the stored procedure using 'sys.path.append()'.
• B. Install 'sentiment_analyzer.py' and 'nltk' on each Snowflake virtual warehouse node and set the 'PYTHONPATH' environment variable. (This will require contacting Snowflake support.)
• C. Create a Snowflake Anaconda channel package containing 'sentiment_analyzer.pV and 'nltk' using 'conda build' , then reference this package in your stored procedure's 'imports' parameter.
• D. Create a ZIP file containing 'sentiment_analyzer.py' and the required 'nltk' modules, upload it to a stage, and specify the stage path in the 'imports' parameter of the 'sproc' decorator.
• E. Include the code from 'sentiment_analyzer.py' directly within the stored procedure's Python code and download 'nltk' modules from the internet each time the stored procedure is executed.

You are tasked with optimizing a Snowpark application that uses a Python UDF to perform complex string manipulations on a large dataset. The current implementation uses a scalar UDF. You are considering converting it to a vectorized UDF. What are the key considerations and potential limitations you need to address during the conversion to ensure correctness and optimal performance? Choose all that apply:

• A. The vectorized UDF should utilize libraries like NumPy or Pandas for efficient array processing, but it's important to be aware of the limitations on available Python packages in the Snowflake environment.
• B. The vectorized UDF's return type must be compatible with Snowpark's data types, and the UDF should return an array of the appropriate type with the same length as the input arrays.
• C. Vectorized UDFs always perform better than scalar UDFs, regardless of the complexity of the string manipulations or the size of the dataset.
• D. The input and output data types of the vectorized UDF must exactly match the corresponding column data types in the Snowpark DataFrame.
• E. The vectorized UDF must be able to handle NULL values gracefully within the input arrays, as these can cause errors if not explicitly addressed.

You have developed a Snowpark Python application that needs to connect to an external REST API to enrich data during a transformation. The API requires authentication using an API key stored securely. Which of the following approaches is the MOST secure and recommended way to manage the API key within the Snowpark environment?

• A. Store the API key in a secure vault outside of Snowflake and retrieve it using a custom Snowflake external function.
• B. Store the API key as an environment variable within the Snowflake session.
• C. Encrypt the API key using a third-party encryption library and store it in a Snowflake table.
• D. Store the API key in a Snowflake Secret Object and retrieve it within the Snowpark Python code using the function.
• E. Hardcode the API key directly into the Snowpark Python code.