[Mar 29, 2026] Snowflake Dumps - Learn How To Deal With The (DEA-C02) Exam Anxiety
DEMO FREE BEFORE YOU BUY DEA-C02 DUMPS
NEW QUESTION # 70
You're designing a Snowpark data transformation pipeline that requires running a Python function on each row of a large DataFrame. The Python function is computationally intensive and needs access to external libraries. Which of the following approaches will provide the BEST combination of performance, scalability, and resource utilization within the Snowpark architecture?
- A. Use 'DataFrame.foreach(lambda row: my_python_function(row))' to iterate through each row and apply the Python function.
- B. Create a Snowpark UDTF using gudtf(output_schema=StructType([StructField('result', StringType())]), and apply it to the DataFrame using with a lateral flatten operation.
- C. Load the DataFrame into a Pandas DataFrame using and then apply the Python function using Pandas DataFrame operations.
- D. Create a Snowpark UDF using input_types=[StringType()], return_type=StringType())' and apply it to the DataFrame using
- E. Define a stored procedure in Snowflake and use it to execute the Python code on each row by calling it in a loop.
Answer: B,D
Explanation:
Options B and D are the best choices. UDFs and UDTFs allow you to leverage Snowflake's compute resources for parallel processing. The function execution happens on Snowflake's servers, close to the data, minimizing data transfer. By specifying 'packages=['my_package']' , you ensure that the external libraries are available in the execution environment. A UDF is suitable for one-to-one row transformations, while a UDTF is more appropriate if the Python function needs to return multiple rows for each input row (one-to-many). Option A, DataFrame.foreacW , is inefficient for large DataFrames as it processes rows sequentially. Option C, loading into Pandas, is also not ideal as it can lead to out-of-memory errors for very large DataFrames and transfers the data to the client machine. Option E, stored procedures with loops, is less scalable and efficient than UDFs or UDTFs.
NEW QUESTION # 71
You are monitoring a Snowpipe pipeline that loads data from an external stage into a Snowflake table. You observe the following error messages in the PIPE ERRORS view: 'Invalid UTF-8 detected in string'. The data files on the stage are encoded in UTF-8. Which of the following actions, taken individually or in combination, are MOST likely to resolve this issue? (Select TWO)
- A. Ensure the file format definition explicitly specifies 'ENCODING = 'UTF8".
- B. Convert the problematic files to UTF-16 encoding before loading them into the stage.
- C. Modify the COPY INTO statement to include the 'ON ERROR = 'SKIP_FILE" option.
- D. Verify the data files on the stage are actually valid UTF-8 and contain no corrupted characters.
- E. Drop and recreate the external stage with 'TYPE = INTERNAL'.
Answer: A,D
Explanation:
Specifying the encoding explicitly in the file format (A) reinforces the correct interpretation. Validating the file contents (D) ensures the root cause is not data corruption. B is incorrect as it changes the storage location not the encoding problem. C will ignore the problem instead of fixing. E might create other problems depending on downstream apps. The correct and more efficient method is to fix/validate the format used in the file format settings.
NEW QUESTION # 72
You are developing a Python script to perform bulk data updates in a Snowflake table. The script needs to update a large number of rows based on values from a Pandas DataFrame. Which of the following approaches is the most efficient and scalable way to achieve this using the Snowflake Python connector, minimizing the number of database operations?
- A. Use 'SnowflakeCursor.executemany()' with a list of tuples containing the update values.
- B. Iterate through the rows of the Pandas DataFrame and execute an 'UPDATE statement for each row using 'cursor.execute()'.
- C. Construct a single, large 'UPDATE statement with multiple 'CASE WHEN' clauses to update all rows in a single operation.
- D. Create a temporary table in Snowflake, load the DataFrame into the temporary table using , and then use a single 'UPDATE' statement with a 'JOIN' to the temporary table.
- E. Use with the option to insert the updated data into a staging table, then use a 'MERGE' statement to update the target table from the staging table.
Answer: A,E
Explanation:
Options B and D are the most efficient. Option B leverages staging tables and a MERGE statement, which is a highly optimized way to perform bulk updates in Snowflake. This minimizes the number of individual operations and takes advantage of Snowflake's internal optimization. Option D uses 'executemany()' , which sends multiple parameterized queries to Snowflake in a single network round trip, significantly improving performance compared to executing individual UPDATE statements. Option A is the least efficient, as it involves a separate database operation for each row. Option C might be feasible for a small number of updates but becomes unwieldy and inefficient for large datasets. Option E introduces unnecessary complexity with temporary tables; MERGE is a better solution.
NEW QUESTION # 73
A data engineering team is building a real-time fraud detection system. They have a large 'TRANSACTIONS table that grows rapidly. They need to calculate the average transaction amount per merchant daily. The following query is used:
This query is run every hour and is performance-critical. Which of the following materialized view definitions would provide the BEST performance improvement, considering the need for near real-time data and minimal latency?
- A. Option A
- B. Option E
- C. Option B
- D. Option C
- E. Option D
Answer: A
Explanation:
Option A provides the best performance because it pre-computes the aggregation for all time, allowing Snowflake to rewrite the query. Option B adds a WHERE clause that limits the data, negating the benefits of materialized view rewrite. Option C using 'REFRESH COMPLETE ON DEMAND is not ideal for near real-time requirements. Option D filters based on a very short time period and not aligned with original problem where the window is 7 days. Option E calculates SUM and COUNT instead of AVG, doesn't match required output.
NEW QUESTION # 74
You are tasked with creating a Snowpark Java stored procedure to calculate a complex, custom rolling average for a time series dataset. This rolling average requires access to external libraries for statistical calculations. Which of the following steps are necessary to successfully deploy and execute this stored procedure?
- A. Create a stored procedure in Snowflake, specifying the fully qualified path to the JAR file in the stage, the handler class, and the return type.
- B. Package the Java code and all necessary external libraries into a single JAR file.
- C. All of the above.
- D. Grant the necessary privileges on the stage and the database to the role executing the stored procedure.
- E. Upload the JAR file to a Snowflake stage.
Answer: C
Explanation:
All the steps mentioned are necessary. The Java code and its dependencies must be packaged into a JAR (A), which is then uploaded to a Snowflake stage (B). The stored procedure needs to be created with a reference to the JAR file and the handler (C), and finally, appropriate permissions must be granted (D). Therefore, option E is the correct answer.
NEW QUESTION # 75
You're building a data product on the Snowflake Marketplace that includes a view that aggregates data from a table containing Personally Identifiable Information (PII). You need to ensure that consumers of your data product CANNOT directly access the underlying PII data but can only see the aggregated results from the view. What is the MOST secure and recommended approach to achieve this?
- A. Grant 'READ privilege on the internal stage containing the data files backing the PII table.
- B. Grant USAGE privilege on the database containing the PII table and to the share.
- C. Create a stored procedure that returns the aggregated data, and grant EXECUTE privilege on the stored procedure to the share. The stored procedure SELECTs from the PII table.
- D. Grant the 'SELECT privilege only on the to the share used for the Marketplace listing. Do not grant any privileges on the underlying PII table.
- E. Grant the 'SELECT privilege directly on the underlying PII table to the share used for the Marketplace listing, along with the 'SELECT privilege on 'sensitive data view'.
Answer: D
Explanation:
Granting only 'SELECT privilege on the (option B) ensures that consumers can only access the view and not the underlying PII data. Granting 'SELECT on the underlying table (option A) defeats the purpose of the view. Using a stored procedure (option C), while potentially masking the data access, is less performant and can still expose data if not carefully implemented. 'USAGE privilege (option D) only allows access to the database, not the data itself. 'READ' on the stage (option E) allows direct access to the raw data, which exposes the PII.
NEW QUESTION # 76
You are developing a JavaScript stored procedure in Snowflake using Snowpark to perform a complex data transformation. This transformation involves multiple steps: filtering, joining with another table, and aggregating data'. You need to ensure that the stored procedure is resilient to failures and can be easily debugged. Which of the following practices would contribute to the robustness and debuggability of your stored procedure? (Select all that apply)
- A. Relying solely on try-catch blocks within the stored procedure to handle all potential exceptions.
- B. Directly manipulating the Snowflake metadata (e.g., table schemas) within the stored procedure for dynamic schema evolution.
- C. Breaking down the complex transformation into smaller, modular functions within the stored procedure and testing each function independently.
- D. Passing the 'snowflake' binding as an argument to each modular function to facilitate logging and SQL execution within those functions.
- E. Using Snowpark's logging capabilities to record intermediate results and error messages at various stages of the transformation.
Answer: C,D,E
Explanation:
Options B, C, and D are correct. Logging intermediate results allows you to track the flow of data and identify the point of failure. Modularizing the code and testing individual functions makes debugging easier. Passing the 'snowflake' binding allows each module to log and execute SQL. Option A is insufficient, complex error requires more granular logging. Option E is dangerous and should be avoided as metadata changes should ideally be performed outside of transformation stored procedure and should be managed by orchestration tools.
NEW QUESTION # 77
You are designing a system to monitor data access patterns in Snowflake. You want to capture detailed information about all queries executed, including the user, query text, execution time, and any potential data access violations based on security policies. Which of the following approaches, used in combination, would provide the MOST comprehensive and scalable solution for this monitoring requirement? (Select TWO)
- A. Implement Snowflake's Event Tables and configure them to capture security-related events, such as data access policy violations.
- B. Enable query tagging and insert custom tags into each SQL statement indicating sensitive data access. Then, query 'QUERY HISTORY filtering on these tags.
- C. Create a stored procedure to intercept all SQL commands before execution, log them, and then execute them using 'EXECUTE IMMEDIAT
- D. Enable the 'QUERY_HISTORY view in the 'ACCOUNT_USAGE' schema and periodically query it using a scheduled task.
- E. Configure the 'SNOWFLAKE database's audit logs and stream them to an external security information and event management (SIEM) system.
Answer: A,E
Explanation:
Snowflake's Event Tables are designed to capture specific events related to data access and security policy violations in a structured manner. These tables provide detailed insights into security-related activities. Configuring Snowflake's audit logs and streaming them to a SIEM system enables centralized security monitoring and analysis. This approach provides a comprehensive view of all security-related events across the Snowflake environment. Using 'QUERY _ HISTORY' will get only high level statistics. Query tagging adds overhead and is not comprehensive. Implementing a stored procedure to intercept SQL commands is not a scalable or recommended approach due to performance implications and potential security risks.
NEW QUESTION # 78
You are designing a data pipeline using Snowpipe to ingest data from multiple S3 buckets into a single Snowflake table. Each S3 bucket represents a different data source and contains files in JSON format. You want to use Snowpipe's auto-ingest feature and a single Snowpipe object for all buckets to simplify management and reduce overhead. However, each data source has a different JSON schem a. How can you best achieve this goal while ensuring data is loaded correctly and efficiently into the target table?
- A. Use a single Snowpipe with a generic FILE FORMAT that can handle all possible JSON schemas. Implement a VIEW on top of the target table to transform and restructure the data based on the source bucket.
- B. Since Snowpipe cannot handle multiple schemas with a single pipe, pre-process the data in S3 using an AWS Lambda function to transform all files into a common schema before they are ingested by the Snowpipe.
- C. Create a separate Snowpipe for each S3 bucket. Although this creates more Snowpipe objects, it allows you to specify a different FILE FORMAT and transformation logic for each data source.
- D. Use a single Snowpipe and leverage Snowflake's VARIANT data type to store the raw JSON data. Create separate external tables, each pointing to a specific S3 bucket, and use SQL queries to transform and load the data into the target table.
- E. Use a single Snowpipe and leverage Snowflake's ability to call a user-defined function (UDF) within the 'COPY INTO' statement to transform the data based on the S3 bucket path. The UDF can parse the bucket path and apply the appropriate JSON schema transformation.
Answer: E
Explanation:
The most efficient and manageable approach is to use a single Snowpipe with a UDF to handle schema variations. The UDF can inspect the S3 bucket path (available as metadata within the 'COPY INTO' statement) and apply the correct transformation logic for each data source. Creating separate Snowpipes (A) adds unnecessary overhead. Using a generic 'FILE FORMAT and a VIEW (B) might work for simple transformations, but it becomes complex with significant schema differences. Using VARIANT and external tables (C) defeats the purpose of Snowpipe. Pre-processing in S3 (E) adds complexity outside of Snowflake. UDF provides schema flexibility during ingest and leverages Snowpipe's capabilities directly.
NEW QUESTION # 79
You have a table 'EVENTS' containing application event data with columns 'EVENT ID, 'USER ID, 'EVENT TYPE, and EVENT DETAILS (VARCHAR). The 'EVENT DETAILS column contains comma-separated key-value pairs (e.g., 'location=USA,device=mobile,os=iOS'). Your objective is to transform this structured data into a VARIANT column named EVENT JSON' in a new table 'EVENTS JSON'. The data in EVENT DETAILS has inconsistent key-value pairs across different rows. Which of the following methods are the most efficient and scalable to parse the key-value pairs in 'EVENT DETAILS' and construct the JSON objects?
- A. Use a Java UDF that iterates through the string, splitting it based on commas and equals signs, and then constructs a JSON object using a JSON library.
- B. Use 'SPLIT to split the key-value pairs into an array, then use a LATERAL FLATTEN to create rows from array, then use 'SPLIT again to split each row by '='. Finally, construct the JSON using 'OBJECT CONSTRUCT.
- C. Utilize to split the key-value pairs into rows, then use 'REGEXP_EXTRACT to extract the key and value. Finally, use 'OBJECT_CONSTRUCT and to construct the JSON object.
- D. Use only REGEXP EXTRACT ALL' with appropriate regular expressions to extract all keys and values into arrays, then use a JavaScript UDF to combine them into a JSON object.
- E. Use a combination of 'SPLIT, 'REGEXP_REPLACE and 'OBJECT_CONSTRUCT within a user-defined function (UDF) to parse the string and build the JSON object.
Answer: B,C
Explanation:
Options B and E are the most efficient because they use Snowflake's built-in functions for parsing the data before constructing the JSON object. 'SPLIT TO_TABLE' (B) and LATERAL FLATTEN (E) are the more scalable way, if the number of key-value pairs might be high in string. While UDFs (A, C, and D) can achieve the transformation, they can be less performant and harder to maintain compared to SQL-based solutions. 'REGEXP EXTRACT ALL' is less efficient in this case as you would still need to iterate through the arrays it creates. Splitting data with 'SPLIT and utilizing LATERAL FLATTEN provides a good balance between performance and readability for handling semi-structured data within Snowflake's SQL environment.
NEW QUESTION # 80
You are the provider of a data product on the Snowflake Marketplace. You need to grant a trial access to a potential consumer You want to provide limited access for 7 days to specific tables in your database. Which of the following steps are REQUIRED to accomplish this?
(Select all that apply)
- A. Grant OWNERSHIP on the specific tables to the consumer's account temporarily.
- B. Create a new role, grant USAGE privilege on the database and SELECT privilege on the specific tables to this role, and then grant this role to the trial consumer.
- C. Create a new share specifically for the trial consumer, granting USAGE privilege on the database and SELECT privilege on the specific tables.
- D. Contact Snowflake support to enable trial access for the consumer's account.
- E. Monitor the consumer's query history to ensure they are only accessing the allowed tables.
Answer: C
Explanation:
Option A is correct. You need to create a specific share granting the required privileges (USAGE on the database and SELECT on the tables) to the consumer's account. Option B suggests creating a role and granting it to the consumer; while possible, it's not the direct method using shares for Marketplace access. Option C is a monitoring task, not a setup step. Option D is incorrect; this can be done directly in Snowflake. Option E is incorrect; OWNERSHIP should not be granted temporarily as it gives full control over the object.
NEW QUESTION # 81
You have a Snowflake table 'CUSTOMER DATA with a column 'EMAIL' containing customer email addresses. You need to classify this column as 'PII' using a tag named 'SENSITIVITY' and value 'CONFIDENTIAL'. Also, you want all queries accessing this 'EMAIL' column to be logged, with specific details about who accessed it and when. You already have appropriate roles and privileges to perform the required operations. Which of the following SQL statements, when executed in sequence, will achieve this goal, assuming appropriate logging mechanisms are already configured to read from the Snowflake ACCESS HISTORY view?
- A.
- B.
- C.
- D.
- E.
Answer: E
Explanation:
The correct sequence of SQL statements is in Option D. First, the tag 'SENSITIVITY' needs to be created. Second, although not explicitly a 'tag value' object, you still need to create a SENSITIVITY tag object. This makes the tag value 'CONFIDENTIAL' available. Then, the tag is applied to the column using the 'ALTER TABLE MODIFY COLUMN ... SET TAG' command with the desired value ('CONFIDENTIAL'). Granting USAGE permissions to the 'data_steward' role (though not directly related to the tagging itself) allows that role to manage and view tag assignments, which is important for governance. Options A, B, C, and E are incorrect because they do not correctly create and assign the tag and its value or have some of the GRANT statement.
NEW QUESTION # 82
You are tasked with building a robust data quality monitoring system for a Snowflake data pipeline. The pipeline processes customer order data and loads it into a 'CUSTOMER ORDERS table. You need to implement checks to ensure that certain critical columns (e.g., 'ORDER ID, 'CUSTOMER ID', 'ORDER DATE, meet specific data quality requirements (e.g., not null, valid format, within acceptable range). You want to design a flexible and scalable solution that allows you to easily add, modify, and monitor data quality rules. Select the options to implement that and scale efficiently Assume there is a central Data Quality table for each metrics
- A. Utilize Snowflake's native Data Governance features, such as data masking and row-level security, to enforce data quality rules.
- B. Create a series of individual SQL scripts, each checking a specific data quality rule for a specific column, and schedule these scripts to run using Snowflake tasks.
- C. Implement a Snowpark Python UDF that leverages a data quality library (e.g., Great Expectations) to define and execute data quality rules. The UDF takes a DataFrame representing the data to be checked and returns a DataFrame containing the data quality check results.
- D. Develop a parameterized stored procedure that accepts the table name, column name, data quality rule definition, and threshold values as input parameters. This procedure then dynamically constructs and executes the SQL query to check the data quality rule.
- E. Build a set of custom Snowflake Native Apps to monitor and report on data quality. Each App will focus on one or more critical tables or data quality checks
Answer: C,D
Explanation:
Options B and C represent the best approaches for a flexible and scalable data quality monitoring system. Option B, using a parameterized stored procedure, allows for dynamic rule execution and easy modification of rules. Option C, using a Snowpark Python UDF with a data quality library, provides a more structured and maintainable way to define and execute complex data quality checks, while also taking advantage of Python's rich ecosystem for data manipulation and analysis. Option A is less scalable and harder to maintain. Option D focuses on data security and access control rather than data quality. Option E will be too complex to maintain a large number of tables and checks.
NEW QUESTION # 83
A financial services company is implementing Snowflake. They have a table 'CUSTOMER DATA' containing sensitive information like 'CREDIT CARD NUMBER, 'SSN', and 'ADDRESS'. They need to ensure that: 1) Analysts can only see the last four digits of the 'CREDIT CARD NUMBER. 2) Data scientists require full access to the 'ADDRESS' but should not see the 'SSN'. 3) A dedicated compliance role should be able to view all data in its original format for auditing purposes. Which of the following is the MOST efficient and secure approach to implement this using Snowflake's data masking and RBAC?
- A. Use data encryption for the entire 'CUSTOMER_DATA table and provide decryption keys to specific roles based on their access requirements. Provide the compliance role with the master key.
- B. Create masking policies on the 'SSN' , and 'ADDRESS' columns. Use conditional masking expressions based on the CURRENT ROLE() function to determine what data to show to each role (analysts, data scientists, compliance).
- C. Create separate views for analysts and data scientists, applying masking policies within the views, and grant access to these views based on their respective roles. Additionally, grant the compliance role direct access to the base table.
- D. Replicate the CUSTOMER_DATA table three times, once for each user group (Analysts, Data Scientist and Compliance). Mask sensitive information by altering the data with the respective masking function.
- E. Create dynamic data masking policies on each sensitive column in the 'CUSTOMER_DATA table, associating these policies with specific roles using Snowflake's tag-based masking. Grant roles only the privileges needed to select the columns based on their requirements.
Answer: B
Explanation:
Conditional masking using the CURRENT ROLE() function within masking policies is the most efficient and secure approach. It allows a single table to be used while dynamically controlling data visibility based on the user's role. Views (Option A) can introduce maintenance overhead. Encryption (Option C) is generally used for data at rest and in transit and is not the correct solution for masking. Tag-based masking can add complexity when direct role-based masking is simpler. Replicating the table (Option E) would consume a huge amount of resource, and increase data duplication issues.
NEW QUESTION # 84
You are tasked with processing streaming data in Snowflake using Snowpark Python. The raw data arrives in a DataFrame raw events' with the following schema: 'event id: string', 'event_time: timestamp', 'user id: string', and 'event data: string'. You need to perform the following data transformations: 1 . Extract a specific value from the JSON 'event_data' using the 'get' function to find the 'product_id' and create a new column named 'product id' of type STRING. 2. Filter the DataFrame to include only events where the is NOT NULL and the is within the last hour. 3. Aggregate the filtered data to count the number of events per 'product id'. Which of the following code snippets correctly performs these transformations in an efficient and performant manner?
- A. Option E
- B. Option A
- C. Option B
- D. Option C
- E. Option D
Answer: C
Explanation:
Option B correctly addresses all the requirements. It uses 'product_id').cast('string')' to extract the product_id' from the JSON and cast it to a string; filters for non-null 'product_id' values and 'event_time' within the last hour using 'dateadd' and 'current_timestamp' for efficient time filtering; and then groups by 'product_id' to count the events. Option A includes 'to_timestamp' which is unneccessary. Option C extracts the 'product_id' from the JSON string to create 'product_id' without casting it to string type. This could create issues in later aggregations/filtering if the data types do not match up. Option D uses subtraction on 'current_timestamp' with the addition result of 'dateadd('hour', 1, current_timestamp()Y to perform time filtering. This will subtract a future time from the current time. This is incorrect.Option E passes a SQL string directly to the filter, bypassing Snowpark+s function calls.
NEW QUESTION # 85
A Snowflake table 'CUSTOMER ORDERS is clustered by 'ORDER DATE. You have observed the clustering depth increasing over time, impacting query performance. To improve performance, you decide to recluster the table. However, you need to minimize the impact on concurrent DML operations and cost. Which of the following strategies would be MOST effective in managing this reclustering process?
- A. Create a new table clustered by 'ORDER_DATE, copy data in parallel, and then swap tables.
- B. Use 'CREATE OR REPLACE TABLE with SELECT FROM CUSTOMER ORDERS to rebuild the table with optimized clustering.
- C. Implement a continuous reclustering process using Snowpipe to automatically recluster new data as it arrives.
- D. Recluster the entire table in a single transaction during off-peak hours.
- E. Leverage Snowflake's automatic reclustering feature, monitor its performance, and adjust warehouse size as needed.
Answer: E
Explanation:
Snowflake's automatic reclustering feature is designed specifically to address this scenario. It automatically reclusters data in the background, minimizing the impact on concurrent DML operations. Options A and E will lock the table and can cause performance impacts during peak hours. Option B is more complex and requires significant downtime during the swap. Option C describes Snowpipe data ingestion, which isn't reclustering. While creating clustered tables with Snowpipe is possible, this option does not address the already unclustered data. Adjusting the warehouse size is relevant to reclustering performance but is secondary to enabling the automatic reclustering itself.
NEW QUESTION # 86
You have configured a Kafka Connector to load JSON data into a Snowflake table named 'ORDERS. The JSON data contains nested structures. However, Snowflake is only receiving the top- level fields, and the nested fields are being ignored. Which configuration option within the Kafka Connector needs to be adjusted to correctly flatten and load the nested JSON data into Snowflake?
- A. Configure the 'snowflake.data.field.name' property to specify the column in the Snowflake table where the entire JSON should be loaded as a VARIANT.
- B. Apply the 'org.apache.kafka.connect.transforms.Flatten' transformation to the 'transforms' configuration.
- C. Set the 'value.converter.schemas.enable' property to 'true'.
- D. Enable the 'snowflake.ingest.stage' property and set it to a Snowflake internal stage.
- E. Use the 'transforms' configuration with the 'org.apache.kafka.connect.transforms.ExtractField$Value' transformation to extract specific fields.
Answer: B
Explanation:
The correct answer is E. The 'org.apache.kafka.connect.transforms.Flatten' transformation is designed specifically for flattening nested JSON structures within Kafka Connect. By applying this transformation to the 'transforms' configuration of the Kafka Connector, you can instruct the connector to recursively flatten the nested JSON data before loading it into Snowflake, ensuring that all fields are accessible. Option A utilizes stages and is unrelated to nested structures. Option B enables schemas, which is useful for Avro, but does not inherently flatten nested structures. Option C allows for extraction but would require multiple transformations for each field and would be cumbersome. Option D will only load the full JSON but would not flatten it, failing the requirements.
NEW QUESTION # 87
A retail company wants to store product data in a Snowflake VARIANT column. The product data is currently in a relational table called 'PRODUCTS' with columns 'PRODUCT ID', 'PRODUCT NAME, 'CATEGORY, 'PRICE, and 'DISCOUNT. They want to create a JSON structure where each product is represented as a JSON object, and the entire result set is a JSON array. Which of the following SQL statements will achieve this transformation most efficiently?
- A. Option E
- B. Option A
- C. Option B
- D. Option C
- E. Option D
Answer: C
Explanation:
'JSON ARRAYAGG' is the most efficient way to construct a JSON array from a result set in Snowflake. returns a Snowflake array, which is different from a JSON array. 'TO_JSON' is used to convert a Snowflake VARIANT to a JSON string, and 'ARRAY CONSTRUCT creates a Snowflake array from individual elements. Option E is close but creates an object with single key products and the value being the Array. 'JSON_ARRAYAGG' directly builds a JSON Array.
NEW QUESTION # 88
......
Latest Snowflake DEA-C02 Dumps with Test Engine and PDF: https://pass4lead.newpassleader.com/Snowflake/DEA-C02-exam-preparation-materials.html