[2026] Snowflake Certified SnowPro Specialty - Snowpark

문제1

You are working with a Snowpark DataFrame 'df that contains user profile data'. A column named 'profile' stores user information as JSON, including 'age' (which can be a number or a string), 'is active' (which can be a boolean or a string 'true'/'false'), and registration date' (stored as a string in 'YYYY-MM-DD' format). You need to perform the following data transformations: 1. Cast the 'age' to an integer, defaulting to -1 if casting fails. 2. Cast 'is active' to a boolean, treating 'true' (case-insensitive) as true and any other string as false. 3. Convert 'registration_date' to a date object. Select the code snippets (multiple answers can be correct) that correctly accomplish these tasks using Snowpark DataFrame transformations.

A.

B.

C.

D.

E.

정답: A,D

설명: (Fast2test 회원만 볼 수 있음)

문제2

A data scientist is developing a Snowpark application that needs to authenticate to Snowflake using Key Pair Authentication. Which of the following steps are essential for configuring the Snowflake CLI to enable Key Pair Authentication and then correctly create a Snowpark session? (Select TWO)

A. Set the 'PRIVATE KEY parameter in the Snowflake CLI configuration to the path of the private key file.

B. Set the 'AUTHENTICATOR parameter in the Snowflake CLI configuration to 'EXTERNALBROWSER.

C. Generate an RSA key pair using 'ssh-keygen' and store the private key securely.

D. Configure the user in Snowflake to use the public key by executing 'ALTER USER SET RSA_PUBLIC_KEY="'.

E. Set the 'AUTHENTICATOR parameter in the Snowflake CLI configuration to 'snowflake'.

정답: C,D

설명: (Fast2test 회원만 볼 수 있음)

문제3

Consider a scenario where you're developing a Snowpark stored procedure that accesses sensitive data'. Which of the following strategies, when used together, provide a comprehensive approach to secure this stored procedure and protect the underlying data?
Select all that apply:

A. Masking sensitive data within the stored procedure using Snowflake's dynamic data masking policies.

B. Implementing row-level security policies on the sensitive data tables.

C. Using 'EXECUTE AS OWNER and granting the 'SELECT privilege on the sensitive data tables to the stored procedure's owner role.

D. Encrypting the stored procedure's code using AES encryption before deployment.

E. Using 'EXECUTE AS CALLER and relying on the caller's privileges to access the data.

정답: A,B,E

설명: (Fast2test 회원만 볼 수 있음)

문제4

You have a Snowpark DataFrame 'df that you want to persist as a Snowflake table. You need to ensure the following requirements are met: 1. The table should be created if it does not exist. 2. If the table exists, the new data should be merged with the existing data based on a 'primary_key' column. 3. If a row with a matching 'primary_key' already exists in the target table, update the existing row with the values from the 'df DataFrame. Otherwise, insert the row from 'df into the target table. Which of the following approaches can achieve this using Snowpark?

A. Create a stored procedure that performs a MERGE statement in Snowflake, and call this stored procedure from your Snowpark code.

B. Convert the Snowpark DataFrame to Pandas DataFrame, perform the merge operation using Pandas, and then write the Pandas DataFrame back to Snowflake.

C. There is no direct way to achieve a merge operation directly using Snowpark DataFrame API without either custom stored procedure or staging of dataframe to new table, then running merge query.

D. Use the method, specifying 'primary_key' in the options.

E. Perform a full outer join between the existing table and the DataFrame, then use

정답: A,C

설명: (Fast2test 회원만 볼 수 있음)

문제5

You are tasked with creating a Snowpark stored procedure to perform complex data transformations using a Pandas DataFrame. You want to optimize the performance of the stored procedure by leveraging Snowpark's distributed execution capabilities. Consider the following code snippet:

Which of the following changes to the above code will significantly improve the performance by utilizing Snowpark's distributed execution?

A. Keep the code as is. Pandas DataFrames are always automatically distributed within Snowpark.

B. Split the Pandas DataFrame into smaller chunks and process each chunk in parallel using Python's multiprocessing library before converting back to a Snowpark DataFrame. Then save it to a table.

C. Replace with 'session.table('my_table')'. Perform the 'some_complex_transformation' directly using Snowpark DataFrame operations instead of converting to Pandas.

D. Use instead of 'to_pandas()'. Then, after the transformation, use 'session.write_pandas(transformed_df, 'transformed_table')'.

E. Before calling , apply a 'limit()' function to the Snowflake Dataframe to reduce the size of the Pandas DataFrame to only a subset of the data. Then, apply the complex transformation.

정답: C

설명: (Fast2test 회원만 볼 수 있음)

문제6

Consider the following Snowpark Python code snippet that defines and applies a UDF:

Which of the following modifications would MOST likely improve the performance of this code, assuming the DataFrame 'df contains a large number of rows?

A. Rewrite the 'apply_discount' function to use NumPy arrays internally for vectorized calculations, ensuring compatibility with vectorized UDF execution. The function signature will also need to accept arrays.

B. Use and F.lit(0.2Y instead of 0.1 and 0.2 while creating the dataframe.

C. Specify a different warehouse size when creating the Snowpark session using 'session = Session.builder.config('warehouse', 'XLARGE').configs(connection_params).create()'.

D. Remove the 'input_types' argument from 'session.udf.register' . Snowflake can automatically infer the input types.

E. Change to in the "session.udf.register' call, ensuring the function is updated to handle batches of data.

정답: A,E

설명: (Fast2test 회원만 볼 수 있음)

문제7

You are tasked with optimizing a Snowpark Python application that performs complex data transformations on a large dataset. The application's performance is currently bottlenecked by the data transfer between Snowflake and the client machine running the Python code. Which of the following strategies can effectively minimize data transfer and improve performance?

A. Use Snowpark's lazy evaluation capabilities to defer data transfer until absolutely necessary, perform data filtering and aggregation within Snowflake before bringing data to the client, and utilize vectorized UDFs for performance-critical operations.

B. Convert all Python UDFs to SQL UDFs to leverage Snowflake's query optimizer.

C. Fetch the entire dataset into a Pandas DataFrame on the client machine and perform all data transformations locally.

D. Disable Snowpark's lazy evaluation to ensure that all data is immediately transferred to the client for processing.

E. Increase the number of worker nodes in the Snowflake virtual warehouse to improve data processing speed.

정답: A

설명: (Fast2test 회원만 볼 수 있음)

문제8

You are developing a data pipeline using Snowpark and want to optimize the execution of multiple DataFrame transformations. Which of the following strategies or techniques can you employ to improve performance and reduce execution time? (Select all that apply)

A. Using pushdown optimization by writing UDFs in Scala and ensuring filter operations are applied as early as possible in the data processing pipeline.

B. Using to explicitly define the order in which DataFrames should be processed.

C. Using on intermediate DataFrames that are reused multiple times in subsequent transformations.

D. Leveraging Snowflake's caching mechanisms by using the 'CACHE RESULT clause after complex or frequently used queries.

E. Eagerly evaluating all DataFrame transformations using 'df.collect()' after each transformation to materialize the intermediate results.

정답: A,C

설명: (Fast2test 회원만 볼 수 있음)

문제9

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 must be able to handle NULL values gracefully within the input arrays, as these can cause errors if not explicitly addressed.

B. 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.

C. The input and output data types of the vectorized UDF must exactly match the corresponding column data types in the Snowpark DataFrame.

D. Vectorized UDFs always perform better than scalar UDFs, regardless of the complexity of the string manipulations or the size of the dataset.

E. 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.

정답: A,B,E

설명: (Fast2test 회원만 볼 수 있음)

문제10

You are developing a Snowpark application to process sales data. The application uses a UDF that calls an external Python library with a large memory footprint. After deploying the application, you observe that the Snowflake warehouse frequently runs out of memory, causing the application to fail. Which of the following strategies would be MOST effective in mitigating this issue, while minimizing cost and maintaining performance? Assume the data volume is relatively large and the UDF is computationally intensive.

A. Implement a caching mechanism within the UDF to store intermediate results and reduce the number of calls to the external library. Deploy the UDF with the same warehouse size.

B. Implement the Python UDF as a Snowpark Stored Procedure. Deploy the UDF with the same warehouse size.

C. Increase the warehouse size to the largest available option. This will provide more memory to the UDE

D. Modify the UDF to process data in smaller batches using a generator pattern, reducing memory consumption at any given time. Deploy the UDF with the same warehouse size.

E. Rewrite the UDF in Java using Snowpark API, which generally has a smaller memory footprint than Python. Deploy the UDF with the same warehouse size.

정답: D

설명: (Fast2test 회원만 볼 수 있음)

문제11

Consider the following Snowpark code snippet designed to process data from an event table and calculate a rolling average:

After deploying this code, you observe that the rolling average calculation is significantly slower than expected, even though the virtual warehouse is adequately sized. What is the MOST effective way to optimize the performance of this rolling average calculation in Snowpark, considering the size of window_size ?

A. Reduce the 'window_size' parameter. Smaller windows inherently require less computation.

B. Use the SNOWFLAKML.FORECAST package in the Snowpark DataFrame to forecast the rolling average of events in each of the user session.

C. Utilize Snowflake's APPROX AVG aggregate function in conjunction with a custom UDF to estimate the rolling average, trading off accuracy for performance.

D. Materialize the intermediate 'event_df DataFrame into a temporary table using before applying the window function.

E. Use the 'rangeBetween' method instead of 'rowsBetween' in the 'Windows specification, as it is generally more efficient for numerical data.

정답: E

설명: (Fast2test 회원만 볼 수 있음)

문제12

You have a Snowpark DataFrame containing sensor data'. You need to write this data to a Snowflake stage 'sensor_stage' , creating a new set of files every hour based on the 'timestamp' column (data type: Timestamp). You also want to ensure that the file names include the hour of the timestamp and are written in Avro format with Zstandard compression. The directory structure on the stage should reflect the hourly partitioning. Which of the following approaches offers the most efficient and scalable way to achieve this, while minimizing the number of files written per hour?

A. Create a new DataFrame by adding an 'hour' column extracted from the 'timestamp' column. Then use 'df.write.partitionBy('hour').format('avro').option('compression', 'zstd').mode('append').save('@sensor_stage/')'.

B. Create a view on top of the data and schedule a task which create file in avro with zstd compression by running the select statment with group by hour.

C. Define a stored procedure that iterates through hourly intervals, filters the DataFrame based on the current hour, and writes the filtered DataFrame to the stage using 'df.write.format('avro').option('compression', 'zstd').mode('append').save(f'@sensor_stage/hour={current_hour}/')'

D. Write a Python script that connects to Snowflake, retrieves the entire DataFrame, iterates through each row, determines the hour from the 'timestamp', and writes each row to a separate Avro file named after the hour in the 'sensor_stage'

E. Using scala user defined function (UDF) for write dataframe into stage in avro file format partitioned by Hour and calling it in snowpark dataframe.

정답: A

설명: (Fast2test 회원만 볼 수 있음)

Snowflake Certified SnowPro Specialty - Snowpark - SPS-C01무료 덤프문제 풀어보기

우리와 연락하기

유용한 링크

최신 업데이트