Consider a scenario where you have a large dataset of sensor readings stored in a Snowflake table called 'SENSOR DATA'. You need to build an external function to perform complex calculations on these readings using a custom Python library hosted on AWS Lambda'. The calculation requires significant computational resources, and you want to optimize the data transfer between Snowflake and the Lambda function. The following SQL is provided: CREATE OR REPLACE EXTERNAL FUNCTION ARRAY) RETURNS ARRAY VOLATILE MAX BATCH ROWS = 2000 RETURNS NULL ON NULL INPUT API INTEGRATION = aws_lambda_integration AS 'arn:aws:lambda:us-east-1:123456789012:function:sensorProcessor'; Which of the following options would further optimize the performance and reduce data transfer costs, assuming the underlying Lambda function is correctly configured and functional?

• A. Reduce the number of columns passed to the external function by performing pre-aggregation or filtering on the data within Snowflake before calling the function.
• B. Compress the data before sending it to the external function and decompress it within the Lambda function. Update the Lambda function to compress the array of results before sending it back to Snowflake and use Snowflake+s functions to decompress it.
• C. Increase the 'MAX BATCH ROWS' parameter to the maximum allowed value to send larger batches of data to the external function. Ensure Lambda function memory is increased appropriately.
• D. Rewrite the custom Python library in Java and create a Snowflake User-Defined Function (UDF) instead of using an external function.
• E. Convert the input data to a binary format (e.g., using 'TO_BINARY and FROM_BINARY' functions in Snowflake) before sending it to the Lambda function, and decode it in Lambda to reduce the size of the data being transmitted.

You are using the Snowflake Developer API to automate the creation and management of masking policies. You need to create a masking policy that masks an email address using SHA256 hashing. You also want to ensure that the policy can be applied to multiple tables and columns without modification. Assuming you have already established a connection to Snowflake using the Developer API, which of the following code snippets BEST demonstrates how to create and apply this masking policy using Python?

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

You have a table named 'TRANSACTIONS with the following definition: CREATE TABLE TRANSACTIONS ( TRANSACTION ID NUMBER, TRANSACTION DATE DATE, CUSTOMER_ID NUMBER, AMOUNT PRODUCT_CATEGORY VARCHAR(50) Users frequently query this table using filters on both 'TRANSACTION_DATE and 'PRODUCT CATEGORY. You want to optimize query performance. What is the MOST effective approach?

• A. Create a materialized view joining 'TRANSACTIONS' with a dimension table containing product category information.
• B. Partition the table by 'TRANSACTION DATE
• C. Cluster the table on ' TRANSACTION_DATE and then create a materialized view filtered by PRODUCT_CATEGORY&.
• D. Create separate indexes on 'TRANSACTION DATE' and 'PRODUCT CATEGORY.
• E. Cluster the table using a composite key of '(TRANSACTION_DATE, PRODUCT CATEGORY)'.

You have implemented external tokenization for a sensitive data column in Snowflake using a UDF that calls an external API. After some time, you discover that the external tokenization service is experiencing intermittent outages, causing queries using the tokenized column to fail. What is the BEST approach to mitigate this issue and maintain data availability while minimizing the risk of exposing the raw data?

• A. Implement a try-catch block within the UDF. In the catch block, return a pre-defined, non-sensitive default value instead of attempting to call the external tokenization service. You can't return the raw value.
• B. Implement a masking policy on the column that returns the raw data when the tokenization UDF is unavailable, detected by catching exceptions within the policy logic.
• C. Replicate the tokenized table to another Snowflake region and switch to the replica during outages of the primary region. The tokenization service is guaranteed to be available in at least one region.
• D. Modify the tokenization UDF to cache tokenization mappings locally within the Snowflake environment. When the external service is unavailable, the UDF can use the cached values.
• E. Implement a try-catch block within the UDF. In the catch block, return a pre-defined static token value (same value always) instead of attempting to call the external tokenization service. You can't return the raw value.

Consider a scenario where you're optimizing a data pipeline in Snowflake responsible for aggregating sales data from multiple regions. You've identified that the frequent full refreshes of the target aggregated table are causing significant performance overhead and resource consumption. Which strategies could be employed to optimize these full refreshes without sacrificing data accuracy?

• A. Leverage Snowflake's search optimization service on the base tables. While costly, this will dramatically speed up full table scans performed in the aggregation.
• B. Implement incremental data loading using streams and tasks. This allows you to only process and load the changes that have occurred since the last refresh, reducing the amount of data that needs to be processed.
• C. Schedule the full refreshes during off-peak hours when the Snowflake warehouse is less utilized. This minimizes the impact on other workloads but does not reduce the actual processing time.
• D. Utilize Snowflake's Time Travel feature to clone the previous version of the aggregated table, apply the necessary changes to the clone, and then swap the clone with the original table using 'ALTER TABLE SWAP WITH'. Note that this will impact data availability during the swap operation.
• E. Replace the full refresh with a 'TRUNCATE TABLE' followed by an 'INSERT statement. This approach is faster than 'CREATE OR REPLACE TABLE' and reduces locking.